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

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

@@ -1,16 +1,16 @@
 // 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 { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { fetchFromProxyService } from '@subwallet/extension-base/utils';
 import { assert, compactToU8a, isHex, u8aConcat, u8aEq } from '@polkadot/util';
-const paraSpellEndpoint = 'https://api.lightspell.xyz';
+const version = '/v3';
 const paraSpellApi = {
-  buildXcm: `${paraSpellEndpoint}/x-transfer`,
-  dryRunXcm: `${paraSpellEndpoint}/dry-run`
+  buildXcm: `${version}/x-transfer`,
+  dryRunXcm: `${version}/dry-run`,
+  feeXcm: `${version}/xcm-fee`
 };
-const paraSpellKey = process.env.PARASPELL_API_KEY || '';
 function txHexToSubmittableExtrinsic(api, hex) {
   try {
     assert(isHex(hex), 'Expected a hex-encoded call');
@@ -73,7 +73,7 @@ export async function buildXcm(request) {
     substrateApi
   } = request;
   if (!substrateApi) {
-    return Promise.reject(new Error('Substrate API is not available'));
+    throw 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;
@@ -87,13 +87,12 @@ export async function buildXcm(request) {
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
   };
-  const response = await fetch(paraSpellApi.buildXcm, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.buildXcm, {
     method: 'POST',
     body: JSON.stringify(bodyData),
     headers: {
       'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-API-KEY': paraSpellKey
+      Accept: 'application/json'
     }
   });
   if (!response.ok) {
@@ -104,8 +103,6 @@ export async function buildXcm(request) {
   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 {
@@ -120,76 +117,75 @@ export async function dryRunXcm(request) {
   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
+    throw new Error('Token is not support XCM at this time');
   }
-
-  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
+  const bodyData = {
+    senderAddress: sender,
+    address: recipient,
+    from: paraSpellChainMap[originChain.slug],
+    to: paraSpellChainMap[destinationChain.slug],
+    currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
+  };
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.dryRunXcm, {
+    method: 'POST',
+    body: JSON.stringify(bodyData),
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    return {
+      origin: {
+        success: false,
+        failureReason: error.message
       }
-    });
-    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;
+  return await response.json();
 }
-export async function dryRunXcmV2(request) {
-  var _originTokenInfo$meta5, _originTokenInfo$meta6;
+export async function estimateXcmFee(request) {
+  var _fromTokenInfo$metada, _fromTokenInfo$metada2;
   const {
-    destinationChain,
-    originChain,
-    originTokenInfo,
+    fromChainInfo,
+    fromTokenInfo,
     recipient,
     sender,
-    sendingValue
+    toChainInfo,
+    value
   } = 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;
+  const psAssetType = (_fromTokenInfo$metada = fromTokenInfo.metadata) === null || _fromTokenInfo$metada === void 0 ? void 0 : _fromTokenInfo$metada.paraSpellAssetType;
+  const psAssetValue = (_fromTokenInfo$metada2 = fromTokenInfo.metadata) === null || _fromTokenInfo$metada2 === void 0 ? void 0 : _fromTokenInfo$metada2.paraSpellValue;
   if (!psAssetType || !psAssetValue) {
-    throw new Error('Token is not support XCM at this time');
+    console.error('Lack of paraspell metadata');
+    return undefined;
   }
   const bodyData = {
     senderAddress: sender,
     address: recipient,
-    from: paraSpellChainMap[originChain.slug],
-    to: paraSpellChainMap[destinationChain.slug],
-    currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
+    from: paraSpellChainMap[fromChainInfo.slug],
+    to: paraSpellChainMap[toChainInfo.slug],
+    currency: createParaSpellCurrency(psAssetType, psAssetValue, value)
   };
-  const response = await fetch(paraSpellApi.dryRunXcm, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.feeXcm, {
     method: 'POST',
     body: JSON.stringify(bodyData),
     headers: {
       'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-API-KEY': paraSpellKey
+      Accept: 'application/json'
     }
   });
   if (!response.ok) {
-    const error = await response.json();
-    throw new Error(error.message);
+    console.error('Failed to request estimate fee');
+    return undefined;
   }
   return await response.json();
 }
 function createParaSpellCurrency(assetType, assetValue, amount) {
   // todo: handle complex conditions for asset has same symbol in a chain: Id, Multi-location, ...
+  // todo: or update all asset to use multi-location
   return {
     [assetType]: assetValue,
     amount

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

@@ -21,6 +21,7 @@ export declare const _BALANCE_CHAIN_GROUP: {
     centrifuge: string[];
     supportBridged: string[];
     bittensor: string[];
+    moonbeam: string[];
 };
 export declare const _BALANCE_TOKEN_GROUP: {
     crab: string[];

package/services/chain-service/constants.js

@@ -29,13 +29,14 @@ 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', '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'],
+  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'hydradx_rococo', 'pendulum', 'amplitude', 'continuum_network', 'truth_network', 'jamton'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub', 'chainflip_assethub'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge'],
   supportBridged: ['rococo_assethub', 'statemint', 'statemine', 'polimec'],
-  bittensor: ['bittensor', 'bittensor_testnet']
+  bittensor: ['bittensor', 'bittensor_testnet'],
+  moonbeam: ['moonbeam', 'moonriver', 'moonbase']
 };
 export const _BALANCE_TOKEN_GROUP = {
   crab: ['CKTON', 'PKTON'],
@@ -254,11 +255,11 @@ export const _TRANSFER_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
   // crab: ['crab', 'pangolin'],
   bitcountry: ['pioneer', 'bitcountry'],
-  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub'],
+  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub', 'chainflip_assethub'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],
-  pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot'],
+  pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot', 'jamton'],
   centrifuge: ['centrifuge'],
   disable_transfer: ['crab', 'pangolin']
 };

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

@@ -3,10 +3,6 @@ import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/ha
 import { _CardanoApi, _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
 import { PromiseHandler } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
-export declare const API_KEY: {
-    mainnet: string;
-    testnet: string;
-};
 export declare class CardanoApi implements _CardanoApi {
     chainSlug: string;
     apiUrl: string;
@@ -18,11 +14,11 @@ export declare class CardanoApi implements _CardanoApi {
     isApiReadyOnce: boolean;
     isReadyHandler: PromiseHandler<_CardanoApi>;
     isTestnet: boolean;
-    private projectId;
     providerName: string;
     constructor(chainSlug: string, apiUrl: string, { isTestnet, providerName }: _ApiOptions);
     get isApiConnected(): boolean;
     get connectionStatus(): _ChainConnectionStatus;
+    private fetchCardano;
     private updateConnectionStatus;
     get isReady(): Promise<_CardanoApi>;
     updateApiUrl(apiUrl: string): Promise<void>;

package/services/chain-service/handler/CardanoApi.js

@@ -3,13 +3,16 @@
 
 import { cborToBytes, retryCardanoTxStatus } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { createPromiseHandler, fetchFromProxyService } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
 import { hexAddPrefix, isHex } from '@polkadot/util';
-export const API_KEY = {
-  mainnet: process.env.BLOCKFROST_API_KEY_MAIN || '',
-  testnet: process.env.BLOCKFROST_API_KEY_PREP || ''
-};
+
+// export const API_KEY = {
+//   mainnet: process.env.BLOCKFROST_API_KEY_MAIN || '',
+//   testnet: process.env.BLOCKFROST_API_KEY_PREP || ''
+// };
+
 export class CardanoApi {
   // private api: BlockFrostAPI;
 
@@ -25,7 +28,6 @@ export class CardanoApi {
     this.chainSlug = chainSlug;
     this.apiUrl = apiUrl;
     this.isTestnet = isTestnet !== null && isTestnet !== void 0 ? isTestnet : true;
-    this.projectId = isTestnet ? API_KEY.testnet : API_KEY.mainnet;
     this.providerName = providerName || 'unknown';
     // this.api = this.createProvider(isTestnet);
     this.isReadyHandler = createPromiseHandler();
@@ -37,6 +39,9 @@ export class CardanoApi {
   get connectionStatus() {
     return this.connectionStatusSubject.getValue();
   }
+  fetchCardano(path, options) {
+    return fetchFromProxyService(ProxyServiceRoute.CARDANO, path, options, this.isTestnet);
+  }
   updateConnectionStatus(status) {
     const isConnected = status === _ChainConnectionStatus.CONNECTED;
     if (isConnected !== this.isApiConnectedSubject.value) {
@@ -107,12 +112,9 @@ export class CardanoApi {
   }
   async getBalanceMap(address) {
     try {
-      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/addresses/${address}` : `https://cardano-mainnet.blockfrost.io/api/v0/addresses/${address}`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      const path = `/addresses/${address}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const addressBalance = await response.json();
       return addressBalance.amount;
@@ -123,13 +125,10 @@ export class CardanoApi {
   }
   async getUtxos(address, page, limit) {
     try {
-      let url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/addresses/${address}/utxos` : `https://cardano-mainnet.blockfrost.io/api/v0/addresses/${address}/utxos`;
-      url += `?page=${page}&count=${limit}`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      let path = `/addresses/${address}/utxos`;
+      path += `?page=${page}&count=${limit}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const utxos = await response.json();
       return utxos;
@@ -140,12 +139,9 @@ export class CardanoApi {
   }
   async getSpecificUtxo(txHash) {
     try {
-      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/txs/${txHash}/utxos` : `https://cardano-mainnet.blockfrost.io/api/v0/txs/${txHash}/utxos`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      const path = `/txs/${txHash}/utxos`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const utxo = await response.json();
       return utxo;
@@ -156,11 +152,10 @@ export class CardanoApi {
   }
   async sendCardanoTxReturnHash(tx) {
     try {
-      const url = this.isTestnet ? 'https://cardano-preprod.blockfrost.io/api/v0/tx/submit' : 'https://cardano-mainnet.blockfrost.io/api/v0/tx/submit';
-      const response = await fetch(url, {
+      const path = '/tx/submit';
+      const response = await this.fetchCardano(path, {
         method: 'POST',
         headers: {
-          Project_id: this.projectId,
           'Content-Type': 'application/cbor'
         },
         body: cborToBytes(tx)
@@ -180,12 +175,9 @@ export class CardanoApi {
   async getStatusByTxHash(txHash, ttl) {
     const cronTime = 30000;
     return retryCardanoTxStatus(async () => {
-      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/txs/${txHash}` : `https://cardano-mainnet.blockfrost.io/api/v0/txs/${txHash}`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      const path = `/txs/${txHash}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const txInfo = await response.json();
       if (txInfo.block && txInfo.hash && txInfo.index >= 0) {

package/services/chain-service/index.js

@@ -1233,6 +1233,10 @@ export class ChainService {
             deprecated = true;
             break;
           }
+          if (defaultChainAsset.slug === storedAssetInfo.slug) {
+            duplicated = true;
+            break;
+          }
         }
         if (!duplicated && !deprecated) {
           mergedAssetRegistry[storedAssetInfo.slug] = storedAssetInfo;

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

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

package/services/earning-service/handlers/native-staking/tao.d.ts

@@ -37,17 +37,6 @@ interface Validator {
     take: string;
     apr: string;
 }
-export declare const BITTENSOR_API_KEY_1: string;
-export declare const BITTENSOR_API_KEY_2: string;
-export declare const BITTENSOR_API_KEY_3: string;
-export declare const BITTENSOR_API_KEY_4: string;
-export declare const BITTENSOR_API_KEY_5: string;
-export declare const BITTENSOR_API_KEY_6: string;
-export declare const BITTENSOR_API_KEY_7: string;
-export declare const BITTENSOR_API_KEY_8: string;
-export declare const BITTENSOR_API_KEY_9: string;
-export declare const BITTENSOR_API_KEY_10: string;
-export declare const bittensorApiKey: () => string;
 export declare class BittensorCache {
     private static instance;
     private cache;

package/services/earning-service/handlers/native-staking/tao.js

@@ -8,31 +8,13 @@ import { getEarningStatusByNominations } from '@subwallet/extension-base/koni/ap
 import { _getAssetDecimals, _getAssetSymbol } from '@subwallet/extension-base/services/chain-service/utils';
 import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
 import { BasicTxErrorType, EarningStatus } from '@subwallet/extension-base/types';
-import { formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { fetchFromProxyService, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BN, BN_ZERO } from '@polkadot/util';
 import { calculateReward } from "../../utils/index.js";
 import { DEFAULT_DTAO_MINBOND } from "./dtao.js";
-export const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
-export const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
-export const BITTENSOR_API_KEY_3 = process.env.BITTENSOR_API_KEY_3 || '';
-export const BITTENSOR_API_KEY_4 = process.env.BITTENSOR_API_KEY_4 || '';
-export const BITTENSOR_API_KEY_5 = process.env.BITTENSOR_API_KEY_5 || '';
-export const BITTENSOR_API_KEY_6 = process.env.BITTENSOR_API_KEY_6 || '';
-export const BITTENSOR_API_KEY_7 = process.env.BITTENSOR_API_KEY_7 || '';
-export const BITTENSOR_API_KEY_8 = process.env.BITTENSOR_API_KEY_8 || '';
-export const BITTENSOR_API_KEY_9 = process.env.BITTENSOR_API_KEY_9 || '';
-export const BITTENSOR_API_KEY_10 = process.env.BITTENSOR_API_KEY_10 || '';
-function random(...keys) {
-  const validKeys = keys.filter(key => key);
-  const randomIndex = Math.floor(Math.random() * validKeys.length);
-  return validKeys[randomIndex];
-}
-export const bittensorApiKey = () => {
-  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2, BITTENSOR_API_KEY_3, BITTENSOR_API_KEY_4, BITTENSOR_API_KEY_5, BITTENSOR_API_KEY_6, BITTENSOR_API_KEY_7, BITTENSOR_API_KEY_8, BITTENSOR_API_KEY_9, BITTENSOR_API_KEY_10);
-};
-
 /* Fetch data */
 export class BittensorCache {
   static instance = null;
@@ -59,13 +41,11 @@ export class BittensorCache {
     return this.promise;
   }
   async fetchData() {
-    const apiKey = bittensorApiKey();
     try {
-      const resp = await fetch('https://api.taostats.io/api/validator/latest/v1?limit=50', {
+      const resp = await fetchFromProxyService(ProxyServiceRoute.BITTENSOR, '/validator/latest/v1?limit=50', {
         method: 'GET',
         headers: {
-          'Content-Type': 'application/json',
-          Authorization: `${apiKey}`
+          'Content-Type': 'application/json'
         }
       });
       if (!resp.ok) {

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

@@ -5,7 +5,8 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY, XCM_FEE_RATIO, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { YIELD_POOL_STAT_REFRESH_INTERVAL } from '@subwallet/extension-base/koni/api/yield/helper/utils';
-import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetName, _getAssetSymbol, _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
 import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
@@ -217,29 +218,20 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
           const symbol = altInputTokenInfo.symbol;
           const networkName = altChainInfo.name;
-          const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
-          const id = getId();
-          const feeInfo = await this.state.feeService.subscribeChainFee(id, altChainInfo.slug, 'substrate');
-          const xcmRequest = {
-            sender: address,
-            originTokenInfo: altInputTokenInfo,
-            destinationTokenInfo: inputTokenInfo,
-            sendingValue: bnAmount.toString(),
-            recipient: address,
-            destinationChain: this.chainInfo,
-            originChain: altChainInfo,
-            substrateApi: xcmOriginSubstrateApi,
-            feeInfo
-          };
 
           // TODO: calculate fee for destination chain
-          let xcmFee;
-          const xcmFeeByDryRun = await dryRunXcmExtrinsicV2(xcmRequest);
-          if (xcmFeeByDryRun.fee) {
-            xcmFee = BigN(xcmFeeByDryRun.fee).multipliedBy(XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
-          } else {
+          const xcmFeeInfo = await estimateXcmFee({
+            fromChainInfo: altChainInfo,
+            fromTokenInfo: altInputTokenInfo,
+            toChainInfo: this.chainInfo,
+            recipient: address,
+            sender: address,
+            value: bnAmount.toString()
+          });
+          if (!xcmFeeInfo) {
             throw new Error('Error estimating XCM fee');
           }
+          const xcmFee = BigN(xcmFeeInfo.origin.fee).multipliedBy(XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
           const fee = {
             slug: altInputTokenSlug,
             amount: xcmFee

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

@@ -7,8 +7,9 @@ import { validateSpendingAndFeePayment } from '@subwallet/extension-base/core/lo
 import { _isAccountActive } from '@subwallet/extension-base/core/substrate/system-pallet';
 import { _isAcrossBridgeXcm, _isSnowBridgeXcm, _isXcmWithinSameConsensus } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
-import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _isAcrossChainBridge, AcrossErrorMsg } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _getAssetDecimals, _getAssetOriginChain, _getAssetSymbol, _getChainNativeTokenSlug, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, SwapStepType, TransferTxErrorType } from '@subwallet/extension-base/types';
@@ -121,11 +122,15 @@ export class SwapBaseHandler {
       };
 
       // TODO: calculate fee for destination chain
-      const bridgeFeeByDryRun = await dryRunXcmExtrinsicV2(xcmRequest);
-      if (!bridgeFeeByDryRun.fee) {
-        return undefined;
-      }
-      const estimatedBridgeFee = BigN(bridgeFeeByDryRun.fee).multipliedBy(FEE_RATE_MULTIPLIER.medium).toFixed(0, 1);
+      const xcmFeeInfo = await estimateXcmFee({
+        fromChainInfo: xcmRequest.originChain,
+        fromTokenInfo: xcmRequest.originTokenInfo,
+        toChainInfo: xcmRequest.destinationChain,
+        recipient: xcmRequest.recipient,
+        sender: xcmRequest.sender,
+        value: xcmRequest.sendingValue
+      });
+      const estimatedBridgeFee = BigN((xcmFeeInfo === null || xcmFeeInfo === void 0 ? void 0 : xcmFeeInfo.origin.fee) || '0').multipliedBy(FEE_RATE_MULTIPLIER.medium).toFixed(0, 1);
       const fee = {
         feeComponent: [{
           feeType: SwapFeeType.NETWORK_FEE,

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

@@ -5,12 +5,10 @@ import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
-export declare const CHAINFLIP_BROKER_API: string;
 export declare class ChainflipSwapHandler implements SwapBaseInterface {
     private readonly isTestnet;
     private swapBaseHandler;
     providerSlug: SwapProviderId;
-    private baseUrl;
     constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
     get chainService(): ChainService;
     get balanceService(): BalanceService;

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

@@ -8,15 +8,17 @@ import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/e
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
 import { _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { getChainflipSwap } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, 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';
 const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
 const INTERMEDIARY_TESTNET_ASSET_SLUG = COMMON_ASSETS.USDC_SEPOLIA;
-export const CHAINFLIP_BROKER_API = process.env.CHAINFLIP_BROKER_API || '';
 export class ChainflipSwapHandler {
+  // private baseUrl: string;
+  // private assetsUrl: string;
+
   constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
       chainService,
@@ -27,8 +29,10 @@ export class ChainflipSwapHandler {
     });
     this.isTestnet = isTestnet;
     this.providerSlug = isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET;
-    this.baseUrl = getChainflipSwap(isTestnet);
+    // this.baseUrl = getChainflipSwap(isTestnet);
+    // this.assetsUrl = getAssetsUrl(isTestnet);
   }
+
   get chainService() {
     return this.swapBaseHandler.chainService;
   }
@@ -76,23 +80,31 @@ export class ChainflipSwapHandler {
     if (processMetadata.destChain !== quoteMetadata.destChain || processMetadata.srcChain !== quoteMetadata.srcChain) {
       throw new Error('Metadata for Chainflip not found');
     }
+    const assetsResponse = await fetchFromProxyService(ProxyServiceRoute.CHAINFLIP, '/assets', {
+      method: 'GET'
+    }, this.isTestnet);
+    const _allAssets = await assetsResponse.json();
+    const allAssets = _allAssets.assets;
+    const sourceAsset = allAssets.find(asset => asset.network === processMetadata.srcChain && asset.ticker === fromAssetId);
+    const destinationAsset = allAssets.find(asset => asset.network === processMetadata.destChain && asset.ticker === toAssetId);
+    if (!sourceAsset || !destinationAsset) {
+      throw new Error('Error get Chainflip data');
+    }
     const depositParams = {
-      sourceChain: processMetadata.srcChain,
       destinationAddress: receiver,
-      destinationAsset: toAssetId,
-      destinationChain: processMetadata.destChain,
+      destinationAsset: destinationAsset.id,
+      sourceAsset: sourceAsset.id,
       minimumPrice: minReceive,
       // minimum accepted price for swaps through the channel
       refundAddress: address,
       // address to which assets are refunded
-      retryDurationInBlocks: '100',
-      // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
-      sourceAsset: fromAssetId
+      retryDurationInBlocks: '100' // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
     };
-    const url = `${this.baseUrl}&${new URLSearchParams(depositParams).toString()}`;
-    const response = await fetch(url, {
+
+    const path = `/swap?${new URLSearchParams(depositParams).toString()}`;
+    const response = await fetchFromProxyService(ProxyServiceRoute.CHAINFLIP, path, {
       method: 'GET'
-    });
+    }, this.isTestnet);
     const data = await response.json();
     if (!data.id || !data.address || data.address === '' || !data.issuedBlock || !data.network || !data.channelId) {
       throw new Error('Error get Chainflip data');

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

@@ -8,7 +8,6 @@ import { SwapBaseInterface } from './base-handler';
 export interface KyberSwapQuoteMetadata {
     priceImpact?: string;
 }
-export declare const KYBER_CLIENT_ID: string;
 export declare class KyberHandler implements SwapBaseInterface {
     private swapBaseHandler;
     transactionService: TransactionService;