@subwallet/extension-base 1.3.77-0 → 1.3.79-1

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

@@ -12,6 +12,7 @@ var _utils = require("@subwallet/extension-base/koni/api/yield/helper/utils");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils2 = require("@subwallet/extension-base/services/balance-service/transfer/xcm/utils");
 var _utils3 = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
 var _types = require("@subwallet/extension-base/types");
 var _utils4 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
@@ -214,51 +215,52 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       address,
       amount
     } = params;
-    const bnAmount = new _util.BN(amount);
+    const bnStakeAmount = new _bignumber.default(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.getTransferableBalance(address, inputTokenInfo.originChain, inputTokenSlug);
-    const bnInputTokenBalance = new _util.BN(inputTokenBalance.value);
-    if (!bnInputTokenBalance.gte(bnAmount)) {
+    const bnInputTokenBalance = new _bignumber.default(inputTokenBalance.value);
+    if (amount && !bnInputTokenBalance.gte(bnStakeAmount)) {
       if (this.altInputAsset) {
         const altInputTokenSlug = this.altInputAsset;
         const altInputTokenInfo = this.state.getAssetBySlug(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 bnAltInputTokenBalance = new _bignumber.default(altInputTokenBalance.value || '0');
+        if (bnAltInputTokenBalance.gt((0, _bignumber.default)(0))) {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
           const symbol = altInputTokenInfo.symbol;
           const networkName = altChainInfo.name;
-
-          // TODO: calculate fee for destination chain
-          const xcmFeeInfo = await (0, _utils2.estimateXcmFee)({
+          const xcmRequest = {
             fromChainInfo: altChainInfo,
             fromTokenInfo: altInputTokenInfo,
             toChainInfo: this.chainInfo,
             recipient: address,
             sender: address,
-            value: bnAmount.toString()
-          });
+            value: bnStakeAmount.toString()
+          };
+          const [xcmFeeInfo, _minXcmTransferableAmount] = await Promise.all([(0, _utils2.estimateXcmFee)(xcmRequest), (0, _xcm.getMinXcmTransferableAmount)(xcmRequest)]);
           if (!xcmFeeInfo) {
             throw new Error('Error estimating XCM fee');
           }
-          const xcmFee = (0, _bignumber.default)(xcmFeeInfo.origin.fee).multipliedBy(_constants.XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
+          const xcmOriginFee = (0, _bignumber.default)(xcmFeeInfo.origin.fee).toFixed(0, 1);
+          const xcmDestinationFee = (0, _bignumber.default)(xcmFeeInfo.destination.fee).toFixed(0, 1);
           const fee = {
             slug: altInputTokenSlug,
-            amount: xcmFee
+            amount: xcmOriginFee
           };
-          let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
-          if ((0, _utils3._isNativeToken)(altInputTokenInfo)) {
-            const bnXcmFee = new _util.BN(fee.amount || 0); // xcm fee is paid in native token but swap token is not always native token
-
-            bnTransferAmount = bnTransferAmount.add(bnXcmFee);
+          let sendingValue = bnStakeAmount.minus(bnInputTokenBalance).plus(xcmDestinationFee).toString();
+          const minXcmTransferableAmount = _minXcmTransferableAmount || _constants2.MIN_XCM_LIQUID_STAKING_DOT;
+          if (new _bignumber.default(minXcmTransferableAmount).gt(sendingValue)) {
+            sendingValue = minXcmTransferableAmount;
           }
+          const metadata = {
+            sendingValue,
+            xcmDestinationFee,
+            originTokenInfo: altInputTokenInfo,
+            destinationTokenInfo: inputTokenInfo
+          };
           const step = {
-            metadata: {
-              sendingValue: bnTransferAmount.toString(),
-              originTokenInfo: altInputTokenInfo,
-              destinationTokenInfo: inputTokenInfo
-            },
+            metadata: metadata,
             name: `Transfer ${symbol} from ${networkName}`,
             type: _types.YieldStepType.XCM
           };
@@ -301,31 +303,35 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)]);
   }
   async validateXcmStep(params, path, bnInputTokenBalance) {
+    // todo: BN -> BigN or BigInt
     const processValidation = {
       ok: true,
       status: _types.YieldValidationStatus.OK
     };
-    const bnAmount = new _util.BN(params.amount);
-    const altInputTokenSlug = this.altInputAsset || '';
-    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-    const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    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 xcmFeeValidate = new _util.BN(path.totalFee[1].amount || '0').mul(new _util.BN(_constants.XCM_FEE_RATIO));
-    const bnAltInputTokenBalance = new _util.BN(altInputTokenBalance.value || '0');
-    if (!bnAltInputTokenBalance.sub(missingAmount).sub(xcmFeeValidate).gt(_util.BN_ZERO)) {
+    const metadata = path.steps[1].metadata;
+    const {
+      destinationTokenInfo,
+      originTokenInfo,
+      sendingValue
+    } = metadata;
+    const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
+    const originTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, originTokenInfo.originChain, originTokenInfo.slug);
+    const bnOriginTokenBalance = new _util.BN(originTokenBalance.value || '0');
+    const bnAdjustOriginFee = new _util.BN(path.totalFee[1].amount || '0').mul(new _util.BN(_constants.XCM_MIN_AMOUNT_RATIO));
+    const bnSendingValue = new _util.BN(sendingValue);
+    if (!bnOriginTokenBalance.sub(bnSendingValue).sub(bnAdjustOriginFee).gt(_util.BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFeeValidate);
-      const inputTokenDecimal = (0, _utils3._getAssetDecimals)(inputTokenInfo);
-      const maxBn = bnInputTokenBalance.add(bnAltInputTokenBalance.sub(xcmFeeValidate));
-      const maxValue = (0, _utils4.formatNumber)(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const maxXCMValue = (0, _utils4.formatNumber)(bnMaxXCM.toString(), inputTokenDecimal);
-      const symbol = (0, _utils3._getAssetSymbol)(altInputTokenInfo);
+      const bnMaxXCM = new _util.BN(originTokenBalance.value).sub(bnAdjustOriginFee);
+      const destinationTokenDecimal = (0, _utils3._getAssetDecimals)(destinationTokenInfo);
+      const maxBn = bnInputTokenBalance.add(bnOriginTokenBalance.sub(bnAdjustOriginFee));
+      const maxValue = (0, _utils4.formatNumber)(maxBn.toString(), destinationTokenInfo.decimals || 0);
+      const maxXCMValue = (0, _utils4.formatNumber)(bnMaxXCM.toString(), destinationTokenDecimal);
+      const symbol = (0, _utils3._getAssetSymbol)(originTokenInfo);
       const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = (0, _utils3._getAssetName)(altInputTokenInfo);
-      const currentValue = (0, _utils4.formatNumber)(bnInputTokenBalance.toString(), inputTokenDecimal);
+      const altNetworkName = (0, _utils3._getChainName)(originChainInfo);
+      const currentValue = (0, _utils4.formatNumber)(bnInputTokenBalance.toString(), destinationTokenDecimal);
       processValidation.message = (0, _i18next.t)('bg.EARNING.services.service.earning.specialHandler.maximumInputExceeded', {
         replace: {
           symbol,
@@ -338,6 +344,24 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       });
       return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
     }
+    const id = (0, _getId.getId)();
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
+    const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
+    const xcmRequest = {
+      destinationTokenInfo: destinationTokenInfo,
+      originTokenInfo: originTokenInfo,
+      recipient: params.address,
+      sendingValue,
+      substrateApi,
+      sender: params.address,
+      originChain: originChainInfo,
+      destinationChain: this.chainInfo,
+      feeInfo
+    };
+    const isDryRunSuccess = await (0, _xcm.dryRunXcmExtrinsicV2)(xcmRequest);
+    if (!isDryRunSuccess) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again')];
+    }
     return [];
   }
   async validateJoinStep(id, params, path, bnInputTokenBalance, isXcmOk) {
@@ -357,7 +381,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
     const defaultFeeTokenSlug = this.feeAssets[0];
-    const bnAmount = new _util.BN(params.amount);
+    const bnStakeAmount = new _util.BN(params.amount);
     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');
@@ -371,13 +395,13 @@ class BaseSpecialStakingPoolHandler extends _base.default {
         return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
       }
     }
-    if (!bnAmount.gte(new _util.BN(poolInfo.statistic.earningThreshold.join || '0'))) {
+    if (!bnStakeAmount.gte(new _util.BN(poolInfo.statistic.earningThreshold.join || '0'))) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
       return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL, processValidation.message, processValidation)];
     }
-    if (!isXcmOk && bnAmount.gt(bnInputTokenBalance)) {
+    if (!isXcmOk && bnStakeAmount.gt(bnInputTokenBalance)) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
@@ -401,8 +425,8 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const balanceService = this.state.balanceService;
     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)) {
+    const bnStakeAmount = new _util.BN(params.amount);
+    if (bnStakeAmount.lte(_util.BN_ZERO)) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
@@ -436,31 +460,26 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   async handleTokenApproveStep(data, path) {
     return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
-  async handleXcmStep(data, path, xcmFee) {
+  async handleXcmStep(data, path) {
+    const metadata = path.steps[1].metadata;
+    const xcmStepFee = path.totalFee[1].amount;
+    const address = data.address;
     const {
-      address,
-      amount
-    } = data;
-    const destinationTokenSlug = this.inputAsset;
-    const altInputTokenSlug = this.altInputAsset || '';
-    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-    const originChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
+      destinationTokenInfo,
+      originTokenInfo,
+      sendingValue,
+      xcmDestinationFee
+    } = metadata;
+    const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
     const originTokenSlug = (0, _utils3._getChainNativeTokenSlug)(originChainInfo);
-    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.getTransferableBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
-    const bnInputTokenBalance = new _util.BN(inputTokenBalance.value);
-    const bnXcmFee = new _util.BN(xcmFee);
-    const bnAmount = new _util.BN(amount);
-    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
     const id = (0, _getId.getId)();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
     const xcmRequest = {
       destinationTokenInfo,
       originTokenInfo,
       recipient: address,
-      sendingValue: bnTotalAmount.toString(),
+      sendingValue,
       substrateApi,
       sender: address,
       originChain: originChainInfo,
@@ -476,7 +495,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       destinationNetworkKey: destinationTokenInfo.originChain,
       from: address,
       to: address,
-      value: bnTotalAmount.toString(),
+      value: sendingValue,
       tokenSlug: originTokenSlug,
       showExtraWarning: true
     };
@@ -485,8 +504,14 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
       extrinsic,
       txData: xcmData,
-      transferNativeAmount: bnTotalAmount.toString(),
-      chainType: _KoniTypes.ChainType.SUBSTRATE
+      transferNativeAmount: sendingValue,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      xcmStepFee,
+      xcmDestinationFee: xcmDestinationFee ? {
+        decimals: (0, _utils3._getAssetDecimals)(destinationTokenInfo),
+        symbol: (0, _utils3._getAssetSymbol)(destinationTokenInfo),
+        value: xcmDestinationFee
+      } : undefined
     };
   }
   handleYieldJoin(data, path, currentStep) {
@@ -498,8 +523,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
         return this.handleTokenApproveStep(data, path);
       case _types.YieldStepType.XCM:
         {
-          const xcmFee = path.totalFee[currentStep].amount || '0';
-          return this.handleXcmStep(data, path, xcmFee);
+          return this.handleXcmStep(data, path);
         }
       default:
         return this.handleSubmitStep(data, path);

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

@@ -883,6 +883,7 @@ class EarningService {
     } = params;
     const handler = this.getPoolHandler(slug);
     if (handler) {
+      console.log('all step', await handler.generateOptimalPath(params));
       return handler.generateOptimalPath(params);
     } else {
       throw new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR);

package/cjs/services/swap-service/handler/asset-hub/handler.js

@@ -71,7 +71,10 @@ class AssetHubSwapHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient
       },
       selectedQuote
     } = params;
@@ -93,12 +96,12 @@ class AssetHubSwapHandler {
     const needModifyData = swapXcm || xcmSwapXcm;
     let bnSendingValue = (0, _bignumber.default)(fromAmount);
     let bnExpectedReceive = (0, _bignumber.default)(selectedQuote.toAmount);
-    const sender = (0, _utils3._reformatAddressWithChain)(params.request.address, originChain);
-    let receiver = (0, _utils3._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain);
+    const sender = (0, _utils3._reformatAddressWithChain)(address, originChain, alternativeAddress);
+    let receiver = (0, _utils3._reformatAddressWithChain)(recipient || address, destinationChain);
     if (needModifyData) {
       bnSendingValue = bnSendingValue.multipliedBy(_utils2.DEFAULT_EXCESS_AMOUNT_WEIGHT);
       bnExpectedReceive = bnExpectedReceive.multipliedBy(_utils2.DEFAULT_EXCESS_AMOUNT_WEIGHT);
-      receiver = (0, _utils3._reformatAddressWithChain)(params.request.address, destinationChain);
+      receiver = (0, _utils3._reformatAddressWithChain)(address, destinationChain, alternativeAddress);
     }
     const submitStep = {
       name: 'Swap',

package/cjs/services/swap-service/handler/asset-hub/router.js

@@ -1,14 +1,10 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AssetHubRouter = void 0;
-var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _utils2 = require("@subwallet/extension-base/services/swap-service/handler/asset-hub/utils");
-var _swap = require("@subwallet/extension-base/types/swap");
-var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils = require("@subwallet/extension-base/services/swap-service/handler/asset-hub/utils");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -23,70 +19,10 @@ class AssetHubRouter {
   get nativeToken() {
     return this.chainService.getNativeTokenInfo(this.chain);
   }
-  buildPath(pair) {
-    // const nativeToken = this.nativeToken;
-    // const nativeTokenSlug = nativeToken.slug;
-
-    const assetFrom = this.chainService.getAssetBySlug(pair.from);
-    const assetTo = this.chainService.getAssetBySlug(pair.to);
-    return [assetFrom, assetTo];
-    // if (pair.from === nativeTokenSlug || pair.to === nativeTokenSlug) {
-    //   return [assetFrom, assetTo];
-    // } else {
-    //   return [assetFrom, nativeToken, assetTo];
-    // }
-  }
-  async earlyValidateSwapValidation(request) {
-    const substrateApi = await this.substrateApi.isReady;
-    const paths = this.buildPath(request.pair);
-    const api = await substrateApi.api.isReady;
-    const amount = request.fromAmount;
-    const reserves = await (0, _utils2.getReserveForPath)(api, paths);
-    const amounts = (0, _utils2.estimateTokensForPath)(amount, reserves);
-    const marketRate = (0, _utils2.estimateRateForPath)(reserves);
-    const marketRateAfter = (0, _utils2.estimateRateAfterForPath)(amount, reserves);
-    const priceImpactPct = (0, _utils2.estimatePriceImpactPct)(marketRate, marketRateAfter);
-    const errors = [];
-
-    // Check liquidity
-    const liquidityError = (0, _utils2.checkLiquidityForPath)(amounts, reserves);
-    if (liquidityError) {
-      errors.push(liquidityError);
-    }
-
-    // Check amount token in pool after swap
-    const minAmounts = paths.map(asset => (0, _utils._getTokenMinAmount)(asset));
-    const minAmountAfterSwapError = (0, _utils2.checkMinAmountForPath)(reserves, amounts, minAmounts);
-    if (minAmountAfterSwapError) {
-      errors.push(minAmountAfterSwapError);
-    }
-    const bnAmount = new _bignumber.default(request.fromAmount);
-    if (bnAmount.lte(0)) {
-      errors.push(_swap.SwapErrorType.AMOUNT_CANNOT_BE_ZERO);
-    }
-    const metadata = {
-      chain: this.chainService.getChainInfoByKey(this.chain),
-      toAmount: amounts[amounts.length - 1],
-      quoteRate: marketRate,
-      priceImpactPct: priceImpactPct
-    };
-    return {
-      error: errors[0],
-      metadata
-    };
-  }
-  async estimateAmountOut(pair, amountIn) {
-    const substrateApi = await this.substrateApi.isReady;
-    const paths = this.buildPath(pair);
-    const api = await substrateApi.api.isReady;
-    const reserves = await (0, _utils2.getReserveForPath)(api, paths);
-    const amounts = (0, _utils2.estimateTokensForPath)(amountIn, reserves);
-    return amounts[amounts.length - 1];
-  }
   async buildSwapExtrinsic(path, recipient, amountIn, amountOutMin) {
     const substrateApi = await this.substrateApi.isReady;
     const api = await substrateApi.api.isReady;
-    return (0, _utils2.buildSwapExtrinsic)(api, path, recipient, amountIn, amountOutMin);
+    return (0, _utils.buildSwapExtrinsic)(api, path, recipient, amountIn, amountOutMin);
   }
 }
 exports.AssetHubRouter = AssetHubRouter;

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

@@ -79,6 +79,7 @@ class SwapBaseHandler {
       path,
       request: {
         address,
+        alternativeAddress,
         fromAmount,
         recipient
       },
@@ -102,12 +103,12 @@ class SwapBaseHandler {
       throw Error('Token or chain not found');
     }
     let recipientAddress;
-    const senderAddress = (0, _utils5._reformatAddressWithChain)(address, fromChainInfo);
+    const senderAddress = (0, _utils5._reformatAddressWithChain)(address, fromChainInfo, alternativeAddress);
     if (stepIndex === 0) {
-      recipientAddress = (0, _utils5._reformatAddressWithChain)(address, toChainInfo);
+      recipientAddress = (0, _utils5._reformatAddressWithChain)(address, toChainInfo, alternativeAddress);
     } else {
       // bridge after swap
-      recipientAddress = (0, _utils5._reformatAddressWithChain)(recipient || address, toChainInfo);
+      recipientAddress = (0, _utils5._reformatAddressWithChain)(recipient || address, toChainInfo, alternativeAddress);
     }
     if (!(0, _xcmParser._isXcmWithinSameConsensus)(fromChainInfo, toChainInfo) || (0, _xcmParser._isSnowBridgeXcm)(fromChainInfo, toChainInfo) || (0, _xcmParser._isAcrossBridgeXcm)(fromChainInfo, toChainInfo)) {
       return undefined;

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

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BittensorSwapHandler = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils2 = require("../../chain-service/utils");
+var _baseHandler = require("./base-handler");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BittensorSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, feeService, isTestnet) {
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Bittensor Testnet' : 'Bittensor',
+      providerSlug: isTestnet ? _types.SwapProviderId.BITTENSOR_TESTNET : _types.SwapProviderId.BITTENSOR
+    });
+    this.providerSlug = isTestnet ? _types.SwapProviderId.BITTENSOR_TESTNET : _types.SwapProviderId.BITTENSOR;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+  }
+  async getSubmitStep(params) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: (0, _utils._reformatAddressWithChain)(params.request.address, originChain),
+        receiver: (0, _utils._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain),
+        version: 2
+      }
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+  }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async handleSubmitStep(params) {
+    var _fromAsset$metadata, _toAsset$metadata;
+    const {
+      address,
+      quote
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromNetuid = (0, _utils2._isNativeTokenBySlug)(fromAsset.slug) ? 0 : (_fromAsset$metadata = fromAsset.metadata) === null || _fromAsset$metadata === void 0 ? void 0 : _fromAsset$metadata.netuid;
+    const toNetuid = (0, _utils2._isNativeTokenBySlug)(toAsset.slug) ? 0 : (_toAsset$metadata = toAsset.metadata) === null || _toAsset$metadata === void 0 ? void 0 : _toAsset$metadata.netuid;
+    if (fromNetuid == null || toNetuid == null || fromNetuid === toNetuid) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+    }
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      process: params.process
+    };
+    const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+    const substrateApi = await chainApi.isReady;
+    const _stakeInfo = await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkey(address);
+    const stakeInfo = _stakeInfo.toPrimitive();
+
+    // TAO/ALPHA ratio
+    const priceRatio = new _bignumber.default((0, _utils.toBNString)(quote.rate, (0, _utils2._getAssetDecimals)(fromAsset)));
+    const limitPrice = priceRatio.multipliedBy(new _bignumber.default(1).minus(params.slippage)).integerValue(_bignumber.default.ROUND_DOWN).toFixed();
+    const calls = this.buildSwapCalls({
+      stakeInfo,
+      fromNetuid,
+      toNetuid,
+      amount: new _bignumber.default(quote.fromAmount),
+      limitPrice
+    }, substrateApi.api);
+    let extrinsic;
+    if (calls.length === 1) {
+      extrinsic = calls[0];
+    } else {
+      extrinsic = substrateApi.api.tx.utility.batchAll(calls);
+    }
+    return {
+      txChain: fromAsset.originChain,
+      extrinsic,
+      txData,
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+      // using staked balance so we do not need transferNativeAmount
+    };
+  }
+
+  // Sort hotkeys by stake descending
+  getHotkeysByNetuidDesc(stakeInfo, fromNetuid) {
+    return stakeInfo.filter(i => i.netuid === fromNetuid && new _bignumber.default(i.stake).gt(0)).sort((a, b) => new _bignumber.default(b.stake).minus(a.stake).toNumber());
+  }
+  buildSwapCalls(params, api) {
+    const {
+      amount,
+      fromNetuid,
+      limitPrice,
+      stakeInfo,
+      toNetuid
+    } = params;
+    const hotkeys = this.getHotkeysByNetuidDesc(stakeInfo, fromNetuid);
+    let remaining = amount;
+    const calls = [];
+    for (const item of hotkeys) {
+      if (remaining.lte(0)) {
+        break;
+      }
+      const stake = new _bignumber.default(item.stake);
+      if (stake.lte(0)) {
+        continue;
+      }
+      const swapAmount = _bignumber.default.minimum(stake, remaining);
+      calls.push(api.tx.subtensorModule.swapStakeLimit(item.hotkey, fromNetuid, toNetuid, swapAmount.toFixed(), limitPrice, false));
+      remaining = remaining.minus(swapAmount);
+    }
+    return calls;
+  }
+}
+exports.BittensorSwapHandler = BittensorSwapHandler;

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

@@ -116,7 +116,11 @@ class HydradxHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient,
+        slippage
       },
       selectedQuote
     } = params;
@@ -135,8 +139,8 @@ class HydradxHandler {
     const destinationTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
-    const sender = (0, _utils3._reformatAddressWithChain)(params.request.address, originChain);
-    let receiver = (0, _utils3._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain);
+    const sender = (0, _utils3._reformatAddressWithChain)(address, originChain, alternativeAddress);
+    let receiver = (0, _utils3._reformatAddressWithChain)(recipient || address, destinationChain);
     const actionList = JSON.stringify(path.map(step => step.action));
     const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
     const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
@@ -160,7 +164,7 @@ class HydradxHandler {
             slug: swapPairInfo.slug
           },
           fromAmount: bnSendingValue.toFixed(0, 1),
-          slippage: params.request.slippage
+          slippage: slippage
         });
       } catch (error) {
         throw new Error(`Failed to fetch swap quote: ${error.message}`);
@@ -171,7 +175,7 @@ class HydradxHandler {
       }
       const overrideQuote = quoteAskResponse.quote;
       txHex = overrideQuote.metadata;
-      receiver = (0, _utils3._reformatAddressWithChain)(params.request.address, destinationChain);
+      receiver = (0, _utils3._reformatAddressWithChain)(address, destinationChain, alternativeAddress);
     }
     if (!txHex || !(0, _util.isHex)(txHex)) {
       return Promise.resolve(undefined);