@subwallet/extension-base 1.2.3-0 → 1.2.4-0

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

@@ -74,11 +74,11 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const feeAssetInfo = this.state.chainService.getAssetBySlug(this.feeAssets[0]);
     const altInputAssetInfo = this.state.chainService.getAssetBySlug(this.altInputAsset);
     const inputAssetInfo = this.state.chainService.getAssetBySlug(this.inputAsset);
-    const [inputAssetBalance, altInputAssetBalance, feeAssetBalance] = await Promise.all([this.state.balanceService.getTokenFreeBalance(request.address, inputAssetInfo.originChain, inputAssetInfo.slug), altInputAssetInfo ? this.state.balanceService.getTokenFreeBalance(request.address, altInputAssetInfo.originChain, altInputAssetInfo.slug) : Promise.resolve({
+    const [inputAssetBalance, altInputAssetBalance, feeAssetBalance] = await Promise.all([this.state.balanceService.getTransferableBalance(request.address, inputAssetInfo.originChain, inputAssetInfo.slug), altInputAssetInfo ? this.state.balanceService.getTransferableBalance(request.address, altInputAssetInfo.originChain, altInputAssetInfo.slug) : Promise.resolve({
       symbol: '',
       decimals: 0,
       value: '0'
-    }), this.state.balanceService.getTokenFreeBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
+    }), this.state.balanceService.getTransferableBalance(request.address, feeAssetInfo.originChain, feeAssetInfo.slug)]);
     const bnInputAssetBalance = new _util.BN(inputAssetBalance.value);
     const bnAltInputAssetBalance = new _util.BN(altInputAssetBalance.value);
     const bnMinJoinPool = new _util.BN(poolInfo.statistic.earningThreshold.join);
@@ -200,13 +200,13 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const bnAmount = new _util.BN(amount);
     const inputTokenSlug = this.inputAsset; // assume that the pool only has 1 input token, will update later
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
-    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, inputTokenInfo.originChain, inputTokenSlug);
+    const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new _util.BN(inputTokenBalance.value);
     if (!bnInputTokenBalance.gte(bnAmount)) {
       if (this.altInputAsset) {
         const altInputTokenSlug = this.altInputAsset;
         const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-        const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
+        const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
         const bnAltInputTokenBalance = new _util.BN(altInputTokenBalance.value || '0');
         if (bnAltInputTokenBalance.gt(_util.BN_ZERO)) {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
@@ -279,17 +279,16 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const altInputTokenSlug = this.altInputAsset || '';
     const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    const altInputTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
+    const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
     const missingAmount = bnAmount.sub(bnInputTokenBalance); // TODO: what if input token is not LOCAL ??
     const xcmFee = new _util.BN(path.totalFee[1].amount || '0');
     const xcmAmount = missingAmount.add(xcmFee);
     const bnAltInputTokenBalance = new _util.BN(altInputTokenBalance.value || '0');
-    const altInputTokenMinAmount = new _util.BN(altInputTokenInfo.minAmount || '0');
-    if (!bnAltInputTokenBalance.sub(xcmAmount).gte(altInputTokenMinAmount)) {
+    if (!bnAltInputTokenBalance.sub(xcmAmount).sub(xcmFee).gt(_util.BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const maxBn = bnInputTokenBalance.add(new _util.BN(altInputTokenBalance.value)).sub(xcmFee).sub(altInputTokenMinAmount);
+      const maxBn = bnInputTokenBalance.add(new _util.BN(altInputTokenBalance.value)).sub(xcmFee).sub(xcmFee);
       const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), inputTokenInfo.decimals || 0);
       const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -297,7 +296,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       const inputNetworkName = this.chainInfo.name;
       const altNetworkName = altNetwork.name;
       const currentValue = (0, _utils3.formatNumber)(bnInputTokenBalance.toString(), inputTokenInfo.decimals || 0);
-      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFee).sub(altInputTokenMinAmount);
+      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFee).sub(xcmFee);
       const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), inputTokenInfo.decimals || 0);
       processValidation.message = (0, _i18next.t)('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
         replace: {
@@ -334,7 +333,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
       var _path$totalFee$id;
       const bnFeeAmount = new _util.BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
-      const feeTokenBalance = await this.state.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenSlug);
+      const feeTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenSlug);
       const bnFeeTokenBalance = new _util.BN(feeTokenBalance.value || '0');
       const bnFeeTokenMinAmount = new _util.BN((feeTokenInfo === null || feeTokenInfo === void 0 ? void 0 : feeTokenInfo.minAmount) || '0');
       if (!bnFeeTokenBalance.sub(bnFeeAmount).gte(bnFeeTokenMinAmount)) {
@@ -372,7 +371,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const inputTokenSlug = this.inputAsset;
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
     const balanceService = this.state.balanceService;
-    const inputTokenBalance = await balanceService.getTokenFreeBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
+    const inputTokenBalance = await balanceService.getTransferableBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new _util.BN(inputTokenBalance.value || '0');
     const bnAmount = new _util.BN(params.amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
@@ -422,7 +421,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
     const destinationTokenInfo = this.state.getAssetBySlug(destinationTokenSlug);
     const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
-    const inputTokenBalance = await this.state.balanceService.getTokenFreeBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
+    const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
     const bnInputTokenBalance = new _util.BN(inputTokenBalance.value);
     const bnXcmFee = new _util.BN(xcmFee);
     const bnAmount = new _util.BN(amount);

package/cjs/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -14,7 +14,8 @@ class MigrateTransactionHistoryBySymbol extends _Base.default {
     const state = this.state;
     try {
       const changeSlugsMap = {
-        'commune-NATIVE-C': 'commune-NATIVE-COMAI'
+        'bobMainnet-LOCAL-wBTC-0x03C7054BCB39f7b2e5B2c7AcB37583e32D70Cfa3': 'bobMainnet-LOCAL-WBTC-0x03C7054BCB39f7b2e5B2c7AcB37583e32D70Cfa3',
+        'hydradx_main-LOCAL-LRNA': 'hydradx_main-LOCAL-H2O'
       };
       const allTxs = [];
       await Promise.all(Object.entries(changeSlugsMap).map(async (_ref, i) => {

package/cjs/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -13,7 +13,8 @@ class MigrateAssetSetting extends _Base.default {
   async run() {
     try {
       const changeSlugsMap = {
-        'commune-NATIVE-C': 'commune-NATIVE-COMAI'
+        'bobMainnet-LOCAL-wBTC-0x03C7054BCB39f7b2e5B2c7AcB37583e32D70Cfa3': 'bobMainnet-LOCAL-WBTC-0x03C7054BCB39f7b2e5B2c7AcB37583e32D70Cfa3',
+        'hydradx_main-LOCAL-LRNA': 'hydradx_main-LOCAL-H2O'
       };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};

package/cjs/services/migration-service/scripts/index.js

@@ -57,8 +57,8 @@ var _default = {
   '1.1.28-01': _MigrateEarningVersion.default,
   '1.1.41-01': _DeleteChainStaking.default,
   '1.1.46-01': _AutoEnableSomeTokens.default,
-  '1.1.62-01': _MigrateAssetSetting.default,
-  '1.1.62-02': _MigrateTransactionHistoryBySymbol.default,
+  '1.1.69-03': _MigrateAssetSetting.default,
+  '1.1.69-02': _MigrateTransactionHistoryBySymbol.default,
   '1.2.69-01': _MigrateRemoveGenesisHash.default
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens

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

@@ -7,13 +7,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.SwapBaseHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap = require("@subwallet/extension-base/types/swap");
+var _swap2 = require("@subwallet/extension-base/types/swap");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
-var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -62,18 +62,19 @@ class SwapBaseHandler {
     }
     const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
     const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
-    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
     const bnAlternativeAssetBalance = new _bignumber.default(alternativeAssetBalance.value);
     const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
     const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
     const xcmFee = new _bignumber.default(xcmFeeComponent.amount || '0');
     let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    let editedXcmFee = new _bignumber.default(0);
     if ((0, _utils._isNativeToken)(alternativeAsset)) {
       xcmAmount = xcmAmount.plus(xcmFee);
+      editedXcmFee = xcmFee.times(2);
     }
-    const alternativeTokenMinAmount = new _bignumber.default(alternativeAsset.minAmount || '0');
-    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
-      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+    if (!bnAlternativeAssetBalance.minus((0, _utils._isNativeToken)(alternativeAsset) ? xcmAmount.plus(xcmFee) : xcmFee).gt(0)) {
+      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus((0, _utils._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
       const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), fromAsset.decimals || 0);
       const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
       const symbol = altInputTokenInfo.symbol;
@@ -82,7 +83,7 @@ class SwapBaseHandler {
       const inputNetworkName = chain.name;
       const altNetworkName = alternativeChain.name;
       const currentValue = (0, _utils3.formatNumber)(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus((0, _utils._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
       const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), fromAsset.decimals || 0);
       if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
         return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
@@ -110,7 +111,7 @@ class SwapBaseHandler {
     const feeInfo = params.process.totalFee[stepIndex];
     const feeAmount = feeInfo.feeComponent[0];
     const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
-    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const feeTokenBalance = await this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
     const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
     const bnFeeAmount = new _bignumber.default(feeAmount.amount);
     if (bnFeeAmount.gte(bnFeeTokenBalance)) {
@@ -119,57 +120,42 @@ class SwapBaseHandler {
     return [];
   }
   async validateSwapStep(params, isXcmOk, stepIndex) {
+    // check swap quote timestamp
+    // check balance to pay transaction fee
+    // check balance against spending amount
     if (!params.selectedQuote) {
       return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const selectedQuote = params.selectedQuote;
     const currentTimestamp = +Date.now();
     if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)]);
     }
-    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
     const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
+    const networkFee = stepFee.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
     if (!networkFee) {
       return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
     }
+    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
     const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
     const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
-    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    const bnFeeAmount = new _bignumber.default(networkFee.amount);
-    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    const {
+      fromAmount,
+      minSwap
+    } = params.selectedQuote;
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const balanceError = (0, _swap._validateBalanceToSwap)(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
+    if (balanceError) {
+      return Promise.resolve([balanceError]);
     }
-    if (fromAsset.slug === feeTokenInfo.slug) {
-      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
-        return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
-      }
+    if (!params.recipient) {
+      return Promise.resolve([]);
     }
-    if (params.selectedQuote.minSwap) {
-      const minProtocolSwap = new _bignumber.default(params.selectedQuote.minSwap);
-      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
-        const parsedMinSwapValue = (0, _utils3.formatNumber)(minProtocolSwap, (0, _utils._getAssetDecimals)(fromAsset));
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
-      }
-    }
-
-    const bnSrcAssetMinAmount = new _bignumber.default((0, _utils._getTokenMinAmount)(fromAsset));
-    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
-    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
-      const parsedMaxBalanceSwap = (0, _utils3.formatNumber)(bnMaxBalanceSwap, (0, _utils._getAssetDecimals)(fromAsset));
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
-    }
-    if (params.recipient) {
-      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-      const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(params.recipient);
-      const isEvmDestChain = (0, _utils._isChainEvmCompatible)(destChainInfo);
-      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.INVALID_RECIPIENT)]);
-      }
+    const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const toAssetChain = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const recipientError = (0, _swap._validateSwapRecipient)(toAssetChain, params.recipient);
+    if (recipientError) {
+      return Promise.resolve([recipientError]);
     }
     return Promise.resolve([]);
   }

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

@@ -10,12 +10,13 @@ var _chainList = require("@subwallet/chain-list");
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _swap2 = require("@subwallet/extension-base/core/logic-validation/swap");
 var _transfer = require("@subwallet/extension-base/koni/api/dotsama/transfer");
 var _transfer2 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap2 = require("@subwallet/extension-base/types/swap");
+var _swap3 = require("@subwallet/extension-base/types/swap");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -41,9 +42,10 @@ class ChainflipSwapHandler {
       chainService,
       balanceService,
       providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
-      providerSlug: isTestnet ? _swap2.SwapProviderId.CHAIN_FLIP_TESTNET : _swap2.SwapProviderId.CHAIN_FLIP_MAINNET
+      providerSlug: isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET
     });
     this.isTestnet = isTestnet;
+    this.providerSlug = isTestnet ? _swap3.SwapProviderId.CHAIN_FLIP_TESTNET : _swap3.SwapProviderId.CHAIN_FLIP_MAINNET;
     this.swapSdk = new _swap.SwapSDK({
       network: isTestnet ? 'perseverance' : 'mainnet'
     });
@@ -99,7 +101,7 @@ class ChainflipSwapHandler {
       const toAssetId = this.assetMapping[toAsset.slug];
       if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
         return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
+          error: _swap3.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
       const [supportedDestChains, srcAssets, destAssets] = await Promise.all([this.swapSdk.getChains(srcChainId), this.swapSdk.getAssets(srcChainId), this.swapSdk.getAssets(destChainId)]);
@@ -108,7 +110,7 @@ class ChainflipSwapHandler {
       const destAssetData = destAssets.find(a => a.asset === toAssetId);
       if (!destAssetData || !srcAssetData || !supportedDestChainId) {
         return {
-          error: _swap2.SwapErrorType.UNKNOWN
+          error: _swap3.SwapErrorType.UNKNOWN
         };
       }
       const bnAmount = new _bignumber.default(request.fromAmount);
@@ -117,12 +119,12 @@ class ChainflipSwapHandler {
         const bnMaxProtocolSwap = new _bignumber.default(srcAssetData.maximumSwapAmount);
         if (bnMinSwap.gte(bnMaxProtocolSwap)) {
           return {
-            error: _swap2.SwapErrorType.UNKNOWN
+            error: _swap3.SwapErrorType.UNKNOWN
           };
         }
         if (bnAmount.gte(bnMaxProtocolSwap)) {
           return {
-            error: _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+            error: _swap3.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
             metadata: {
               minSwap: {
                 value: srcAssetData.minimumSwapAmount,
@@ -142,7 +144,7 @@ class ChainflipSwapHandler {
       if (bnAmount.lt(bnMinSwap)) {
         // might miss case when minSwap is 0
         return {
-          error: _swap2.SwapErrorType.NOT_MEET_MIN_SWAP,
+          error: _swap3.SwapErrorType.NOT_MEET_MIN_SWAP,
           metadata: {
             minSwap: {
               value: srcAssetData.minimumSwapAmount,
@@ -175,7 +177,7 @@ class ChainflipSwapHandler {
       };
     } catch (e) {
       return {
-        error: _swap2.SwapErrorType.UNKNOWN
+        error: _swap3.SwapErrorType.UNKNOWN
       };
     }
   }
@@ -193,12 +195,12 @@ class ChainflipSwapHandler {
     const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
     if (!fromAsset || !toAsset) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
+      return new _SwapError.SwapError(_swap3.SwapErrorType.UNKNOWN);
     }
     const earlyValidation = await this.validateSwapRequest(request);
     const metadata = earlyValidation.metadata;
     if (earlyValidation.error) {
-      return (0, _utils2.getChainflipEarlyValidationError)(earlyValidation.error, metadata);
+      return (0, _swap2._getChainflipEarlyValidationError)(earlyValidation.error, metadata);
     }
     const srcChainId = this.chainMapping[fromAsset.originChain];
     const destChainId = this.chainMapping[toAsset.originChain];
@@ -225,7 +227,7 @@ class ChainflipSwapHandler {
               feeComponent.push({
                 tokenSlug,
                 amount: fee.amount,
-                feeType: _swap2.SwapFeeType.NETWORK_FEE
+                feeType: _swap3.SwapFeeType.NETWORK_FEE
               });
               break;
             }
@@ -238,7 +240,7 @@ class ChainflipSwapHandler {
               feeComponent.push({
                 tokenSlug,
                 amount: fee.amount,
-                feeType: _swap2.SwapFeeType.PLATFORM_FEE
+                feeType: _swap3.SwapFeeType.PLATFORM_FEE
               });
               break;
             }
@@ -272,12 +274,12 @@ class ChainflipSwapHandler {
       const errorObj = error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data;
       if (errorObj && errorObj.error && errorObj.error.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
         // todo: Chainflip will improve this
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+        return new _SwapError.SwapError(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
       }
       if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+        return new _SwapError.SwapError(_swap3.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
       }
-      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
+      return new _SwapError.SwapError(_swap3.SwapErrorType.ERROR_FETCHING_QUOTE);
     }
   }
   async validateSwapProcess(params) {
@@ -290,9 +292,9 @@ class ChainflipSwapHandler {
     for (const [index, step] of params.process.steps.entries()) {
       const getErrors = async () => {
         switch (step.type) {
-          case _swap2.SwapStepType.DEFAULT:
+          case _swap3.SwapStepType.DEFAULT:
             return Promise.resolve([]);
-          case _swap2.SwapStepType.TOKEN_APPROVAL:
+          case _swap3.SwapStepType.TOKEN_APPROVAL:
             return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
           default:
             return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
@@ -301,7 +303,7 @@ class ChainflipSwapHandler {
       const errors = await getErrors();
       if (errors.length) {
         return errors;
-      } else if (step.type === _swap2.SwapStepType.XCM) {
+      } else if (step.type === _swap3.SwapStepType.XCM) {
         isXcmOk = true;
       }
     }
@@ -382,9 +384,9 @@ class ChainflipSwapHandler {
     } = params;
     const type = process.steps[currentStep].type;
     switch (type) {
-      case _swap2.SwapStepType.DEFAULT:
+      case _swap3.SwapStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap2.SwapStepType.SWAP:
+      case _swap3.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
@@ -394,7 +396,7 @@ class ChainflipSwapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap2.SwapStepType.SWAP
+        type: _swap3.SwapStepType.SWAP
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }