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

package/services/earning-service/constants/chains.js

@@ -36,4 +36,5 @@ export const CHANNEL_ID = 7;
 export const STAKING_IDENTITY_API_SLUG = {
   statemine: 'peopleKusama',
   statemint: 'polkadot_people'
-};
+};
+export const MIN_XCM_LIQUID_STAKING_DOT = '15000000000';

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

@@ -9,20 +9,19 @@ import { reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { BN_ZERO } from '@polkadot/util';
 import TaoNativeStakingPoolHandler, { DEFAULT_DTAO_MINBOND } from "./tao.js";
-const getAlphaToTaoRateMap = async substrateApi => {
-  const allSubnets = (await substrateApi.api.call.subnetInfoRuntimeApi.getAllDynamicInfo()).toJSON();
-  if (!allSubnets || allSubnets.length === 0) {
-    return {};
-  }
+const getAlphaToTaoRateMap = async (substrateApi, priceScaleDecimals = 9) => {
   const result = Object.create(null);
-  for (const subnet of allSubnets) {
-    const netuid = subnet === null || subnet === void 0 ? void 0 : subnet.netuid;
-    if (netuid === undefined) {
-      continue;
+  const PRICE_SCALE = new BigN(10).pow(priceScaleDecimals);
+  const allSubnetPrices = (await substrateApi.api.call.swapRuntimeApi.currentAlphaPriceAll()).toJSON();
+  if (allSubnetPrices && allSubnetPrices.length > 0) {
+    for (const subnetPrice of allSubnetPrices) {
+      const netuid = subnetPrice === null || subnetPrice === void 0 ? void 0 : subnetPrice.netuid;
+      if (netuid === undefined) {
+        continue;
+      }
+      const rawPrice = subnetPrice !== null && subnetPrice !== void 0 && subnetPrice.price ? new BigN(subnetPrice.price) : new BigN(0);
+      result[netuid] = netuid === 0 ? '1' : rawPrice.dividedBy(PRICE_SCALE).toFixed();
     }
-    const taoIn = subnet !== null && subnet !== void 0 && subnet.taoIn ? new BigN(subnet.taoIn) : new BigN(0);
-    const alphaIn = subnet !== null && subnet !== void 0 && subnet.alphaIn ? new BigN(subnet.alphaIn) : new BigN(0);
-    result[netuid] = netuid === 0 || alphaIn.lte(0) ? '1' : taoIn.dividedBy(alphaIn).toString();
   }
   return result;
 };
@@ -204,7 +203,7 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
     const getPoolPosition = async () => {
       const rawDelegateStateInfos = await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkeys(useAddresses);
       const delegateStateInfos = rawDelegateStateInfos.toPrimitive();
-      const alphaToTaoRateMap = await getAlphaToTaoRateMap(this.substrateApi);
+      const alphaToTaoRateMap = await getAlphaToTaoRateMap(this.substrateApi, this.getAlphaPriceScaleDecimals());
       if (!delegateStateInfos || delegateStateInfos.length === 0) {
         return;
       }

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

@@ -82,10 +82,11 @@ export declare class BittensorCache {
     fetchApr(netuid: number): Promise<ValidatorAprResponse>;
     fetchSubnetFeeRate(netuid: number): Promise<string>;
 }
-export declare const getAlphaToTaoRate: (substrateApi: _SubstrateApi, netuid: number) => Promise<string>;
+export declare const getAlphaToTaoRate: (substrateApi: _SubstrateApi, netuid: number, priceScaleDecimals?: number) => Promise<string>;
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
     readonly availableMethod: YieldPoolMethodInfo;
     protected bittensorCache: BittensorCache;
+    protected getAlphaPriceScaleDecimals(): number;
     protected getMinBond(netuid?: number): Promise<BigN>;
     constructor(state: KoniState, chain: string);
     get maintainBalance(): string;

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

@@ -113,14 +113,16 @@ export class BittensorCache {
     }
   }
 }
-export const getAlphaToTaoRate = async (substrateApi, netuid) => {
-  const subnetInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getDynamicInfo(netuid)).toJSON();
-  if (!subnetInfo) {
+export const getAlphaToTaoRate = async (substrateApi, netuid, priceScaleDecimals = 9) => {
+  if (netuid === 0) {
     return '1';
   }
-  const taoIn = subnetInfo.taoIn ? new BigN(subnetInfo.taoIn) : new BigN(0);
-  const alphaIn = subnetInfo.alphaIn ? new BigN(subnetInfo.alphaIn) : new BigN(0);
-  return netuid === 0 || alphaIn.lte(0) ? '1' : taoIn.dividedBy(alphaIn).toString();
+  const [rawSubnetPrice, rawRootPrice] = await Promise.all([substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(netuid), substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(0)]);
+  const subnetPrice = new BigN(rawSubnetPrice.toString());
+  const defaultScale = new BigN(10).pow(priceScaleDecimals);
+  const rootPrice = new BigN(rawRootPrice.toString());
+  const priceScale = rootPrice.lte(0) ? defaultScale : rootPrice;
+  return subnetPrice.lte(0) ? '0' : subnetPrice.dividedBy(priceScale).toFixed();
 };
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
   availableMethod = {
@@ -132,6 +134,9 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     claimReward: false,
     changeValidator: true
   };
+  getAlphaPriceScaleDecimals() {
+    return _getAssetDecimals(this.nativeToken);
+  }
   async getMinBond(netuid) {
     var _cachedPool$metadata2, _cachedPool$statistic, _cachedPool$statistic2, _onlinePool$metadata2, _onlinePool$statistic, _onlinePool$statistic2;
     // @ts-ignore
@@ -469,7 +474,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const hotkey = selectedValidatorInfo.address;
     const netuid = (_subnetData$netuid = subnetData === null || subnetData === void 0 ? void 0 : subnetData.netuid) !== null && _subnetData$netuid !== void 0 ? _subnetData$netuid : 0;
     const slippage = (_subnetData$slippage = subnetData === null || subnetData === void 0 ? void 0 : subnetData.slippage) !== null && _subnetData$slippage !== void 0 ? _subnetData$slippage : DEFAULT_BITTENSOR_SLIPPAGE;
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** _getAssetDecimals(this.nativeToken)).multipliedBy(1 + slippage);
     const BNlimitPrice = new BigN(limitPrice.integerValue(BigN.ROUND_CEIL).toFixed());
     const extrinsic = chainApi.api.tx.subtensorModule.addStakeLimit(hotkey, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -511,7 +516,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
     }
     const binaryAmount = new BigN(amount);
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** _getAssetDecimals(this.nativeToken)).multipliedBy(1 - slippage);
     const BNlimitPrice = new BigN(limitPrice.integerValue(BigN.ROUND_CEIL).toFixed());
     const extrinsic = apiPromise.api.tx.subtensorModule.removeStakeLimit(selectedTarget, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -527,7 +532,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS)];
     }
     const netuid = (_poolInfo$metadata$su = poolInfo.metadata.subnetData) === null || _poolInfo$metadata$su === void 0 ? void 0 : _poolInfo$metadata$su.netuid;
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid || 0));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid || 0, this.getAlphaPriceScaleDecimals()));
     const minDelegatorStake = await this.getMinBond(netuid);
     const minUnstake = minDelegatorStake.dividedBy(alphaToTaoPrice);
     if (new BigN(amount).lt(minUnstake)) {
@@ -567,7 +572,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     if (originValidator === destValidator) {
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.fromValidatorSameAsTo')));
     }
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const bnMinStake = await this.getMinBond(netuid);
     const minUnstake = bnMinStake.dividedBy(alphaToTaoPrice);
     const formattedMinUnstake = minUnstake.dividedBy(1000000).integerValue(BigN.ROUND_CEIL).dividedBy(1000);

package/services/earning-service/handlers/special.d.ts

@@ -55,7 +55,7 @@ export default abstract class BaseSpecialStakingPoolHandler extends BasePoolHand
     protected validateJoinStep(id: number, params: OptimalYieldPathParams, path: OptimalYieldPath, bnInputTokenBalance: BN, isXcmOk: boolean): Promise<TransactionError[]>;
     validateYieldJoin(params: SubmitYieldJoinData, path: OptimalYieldPath): Promise<TransactionError[]>;
     protected handleTokenApproveStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
-    handleXcmStep(data: SubmitYieldJoinData, path: OptimalYieldPath, xcmFee: string): Promise<HandleYieldStepData>;
+    handleXcmStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
     abstract handleSubmitStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
     handleYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
     handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;

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

@@ -3,11 +3,12 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 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 { ALL_ACCOUNT_KEY, 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 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2, getMinXcmTransferableAmount } 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 { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetSymbol, _getChainName, _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
+import { MIN_XCM_LIQUID_STAKING_DOT } from '@subwallet/extension-base/services/earning-service/constants';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
 import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -207,51 +208,52 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       address,
       amount
     } = params;
-    const bnAmount = new BN(amount);
+    const bnStakeAmount = new BigN(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 BN(inputTokenBalance.value);
-    if (!bnInputTokenBalance.gte(bnAmount)) {
+    const bnInputTokenBalance = new BigN(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 BN(altInputTokenBalance.value || '0');
-        if (bnAltInputTokenBalance.gt(BN_ZERO)) {
+        const bnAltInputTokenBalance = new BigN(altInputTokenBalance.value || '0');
+        if (bnAltInputTokenBalance.gt(BigN(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 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([estimateXcmFee(xcmRequest), getMinXcmTransferableAmount(xcmRequest)]);
           if (!xcmFeeInfo) {
             throw new Error('Error estimating XCM fee');
           }
-          const xcmFee = BigN(xcmFeeInfo.origin.fee).multipliedBy(XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
+          const xcmOriginFee = BigN(xcmFeeInfo.origin.fee).toFixed(0, 1);
+          const xcmDestinationFee = BigN(xcmFeeInfo.destination.fee).toFixed(0, 1);
           const fee = {
             slug: altInputTokenSlug,
-            amount: xcmFee
+            amount: xcmOriginFee
           };
-          let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
-          if (_isNativeToken(altInputTokenInfo)) {
-            const bnXcmFee = new 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 || MIN_XCM_LIQUID_STAKING_DOT;
+          if (new BigN(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: YieldStepType.XCM
           };
@@ -294,31 +296,35 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     return Promise.resolve([new TransactionError(BasicTxErrorType.UNSUPPORTED)]);
   }
   async validateXcmStep(params, path, bnInputTokenBalance) {
+    // todo: BN -> BigN or BigInt
     const processValidation = {
       ok: true,
       status: YieldValidationStatus.OK
     };
-    const bnAmount = new 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 BN(path.totalFee[1].amount || '0').mul(new BN(XCM_FEE_RATIO));
-    const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
-    if (!bnAltInputTokenBalance.sub(missingAmount).sub(xcmFeeValidate).gt(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 BN(originTokenBalance.value || '0');
+    const bnAdjustOriginFee = new BN(path.totalFee[1].amount || '0').mul(new BN(XCM_MIN_AMOUNT_RATIO));
+    const bnSendingValue = new BN(sendingValue);
+    if (!bnOriginTokenBalance.sub(bnSendingValue).sub(bnAdjustOriginFee).gt(BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFeeValidate);
-      const inputTokenDecimal = _getAssetDecimals(inputTokenInfo);
-      const maxBn = bnInputTokenBalance.add(bnAltInputTokenBalance.sub(xcmFeeValidate));
-      const maxValue = formatNumber(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const maxXCMValue = formatNumber(bnMaxXCM.toString(), inputTokenDecimal);
-      const symbol = _getAssetSymbol(altInputTokenInfo);
+      const bnMaxXCM = new BN(originTokenBalance.value).sub(bnAdjustOriginFee);
+      const destinationTokenDecimal = _getAssetDecimals(destinationTokenInfo);
+      const maxBn = bnInputTokenBalance.add(bnOriginTokenBalance.sub(bnAdjustOriginFee));
+      const maxValue = formatNumber(maxBn.toString(), destinationTokenInfo.decimals || 0);
+      const maxXCMValue = formatNumber(bnMaxXCM.toString(), destinationTokenDecimal);
+      const symbol = _getAssetSymbol(originTokenInfo);
       const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = _getAssetName(altInputTokenInfo);
-      const currentValue = formatNumber(bnInputTokenBalance.toString(), inputTokenDecimal);
+      const altNetworkName = _getChainName(originChainInfo);
+      const currentValue = formatNumber(bnInputTokenBalance.toString(), destinationTokenDecimal);
       processValidation.message = t('bg.EARNING.services.service.earning.specialHandler.maximumInputExceeded', {
         replace: {
           symbol,
@@ -331,6 +337,24 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       });
       return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
     }
+    const id = 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 dryRunXcmExtrinsicV2(xcmRequest);
+    if (!isDryRunSuccess) {
+      return [new TransactionError(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) {
@@ -350,7 +374,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
     const defaultFeeTokenSlug = this.feeAssets[0];
-    const bnAmount = new BN(params.amount);
+    const bnStakeAmount = new BN(params.amount);
     if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
       var _path$totalFee$id;
       const bnFeeAmount = new BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
@@ -364,13 +388,13 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
         return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
       }
     }
-    if (!bnAmount.gte(new BN(poolInfo.statistic.earningThreshold.join || '0'))) {
+    if (!bnStakeAmount.gte(new BN(poolInfo.statistic.earningThreshold.join || '0'))) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
       return [new TransactionError(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 = YieldValidationStatus.NOT_ENOUGH_BALANCE;
@@ -394,8 +418,8 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const balanceService = this.state.balanceService;
     const inputTokenBalance = await balanceService.getTransferableBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new BN(inputTokenBalance.value || '0');
-    const bnAmount = new BN(params.amount);
-    if (bnAmount.lte(BN_ZERO)) {
+    const bnStakeAmount = new BN(params.amount);
+    if (bnStakeAmount.lte(BN_ZERO)) {
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
@@ -429,31 +453,26 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
   async handleTokenApproveStep(data, path) {
     return Promise.reject(new TransactionError(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 = _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 BN(inputTokenBalance.value);
-    const bnXcmFee = new BN(xcmFee);
-    const bnAmount = new BN(amount);
-    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
     const id = 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,
@@ -469,7 +488,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       destinationNetworkKey: destinationTokenInfo.originChain,
       from: address,
       to: address,
-      value: bnTotalAmount.toString(),
+      value: sendingValue,
       tokenSlug: originTokenSlug,
       showExtraWarning: true
     };
@@ -478,8 +497,14 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       extrinsic,
       txData: xcmData,
-      transferNativeAmount: bnTotalAmount.toString(),
-      chainType: ChainType.SUBSTRATE
+      transferNativeAmount: sendingValue,
+      chainType: ChainType.SUBSTRATE,
+      xcmStepFee,
+      xcmDestinationFee: xcmDestinationFee ? {
+        decimals: _getAssetDecimals(destinationTokenInfo),
+        symbol: _getAssetSymbol(destinationTokenInfo),
+        value: xcmDestinationFee
+      } : undefined
     };
   }
   handleYieldJoin(data, path, currentStep) {
@@ -491,8 +516,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
         return this.handleTokenApproveStep(data, path);
       case 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/services/earning-service/service.js

@@ -871,6 +871,7 @@ export default 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(BasicTxErrorType.INTERNAL_ERROR);

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

@@ -64,7 +64,10 @@ export class AssetHubSwapHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient
       },
       selectedQuote
     } = params;
@@ -86,12 +89,12 @@ export class AssetHubSwapHandler {
     const needModifyData = swapXcm || xcmSwapXcm;
     let bnSendingValue = BigN(fromAmount);
     let bnExpectedReceive = BigN(selectedQuote.toAmount);
-    const sender = _reformatAddressWithChain(params.request.address, originChain);
-    let receiver = _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain);
+    const sender = _reformatAddressWithChain(address, originChain, alternativeAddress);
+    let receiver = _reformatAddressWithChain(recipient || address, destinationChain);
     if (needModifyData) {
       bnSendingValue = bnSendingValue.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
       bnExpectedReceive = bnExpectedReceive.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
-      receiver = _reformatAddressWithChain(params.request.address, destinationChain);
+      receiver = _reformatAddressWithChain(address, destinationChain, alternativeAddress);
     }
     const submitStep = {
       name: 'Swap',

package/services/swap-service/handler/asset-hub/router.d.ts

@@ -1,7 +1,6 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { AssetHubSwapEarlyValidation, SwapPair, SwapRequest } from '@subwallet/extension-base/types/swap';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 export declare class AssetHubRouter {
     private readonly chain;
@@ -9,8 +8,5 @@ export declare class AssetHubRouter {
     constructor(chain: string, chainService: ChainService);
     get substrateApi(): _SubstrateApi;
     get nativeToken(): _ChainAsset;
-    buildPath(pair: SwapPair): Array<_ChainAsset>;
-    earlyValidateSwapValidation(request: SwapRequest): Promise<AssetHubSwapEarlyValidation>;
-    estimateAmountOut(pair: SwapPair, amountIn: string): Promise<string>;
     buildSwapExtrinsic(path: Array<_ChainAsset>, recipient: string, amountIn: string, amountOutMin: string): Promise<SubmittableExtrinsic<'promise'>>;
 }

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

@@ -1,10 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getTokenMinAmount } from '@subwallet/extension-base/services/chain-service/utils';
-import { buildSwapExtrinsic, checkLiquidityForPath, checkMinAmountForPath, estimatePriceImpactPct, estimateRateAfterForPath, estimateRateForPath, estimateTokensForPath, getReserveForPath } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
-import { SwapErrorType } from '@subwallet/extension-base/types/swap';
-import BigN from 'bignumber.js';
+import { buildSwapExtrinsic } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
 export class AssetHubRouter {
   constructor(chain, chainService) {
     this.chain = chain;
@@ -16,66 +13,6 @@ export 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 getReserveForPath(api, paths);
-    const amounts = estimateTokensForPath(amount, reserves);
-    const marketRate = estimateRateForPath(reserves);
-    const marketRateAfter = estimateRateAfterForPath(amount, reserves);
-    const priceImpactPct = estimatePriceImpactPct(marketRate, marketRateAfter);
-    const errors = [];
-
-    // Check liquidity
-    const liquidityError = checkLiquidityForPath(amounts, reserves);
-    if (liquidityError) {
-      errors.push(liquidityError);
-    }
-
-    // Check amount token in pool after swap
-    const minAmounts = paths.map(asset => _getTokenMinAmount(asset));
-    const minAmountAfterSwapError = checkMinAmountForPath(reserves, amounts, minAmounts);
-    if (minAmountAfterSwapError) {
-      errors.push(minAmountAfterSwapError);
-    }
-    const bnAmount = new BigN(request.fromAmount);
-    if (bnAmount.lte(0)) {
-      errors.push(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 getReserveForPath(api, paths);
-    const amounts = 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;

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

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

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

@@ -0,0 +1,21 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import FeeService from '../../fee-service/service';
+import { SwapBaseInterface } from './base-handler';
+export declare class BittensorSwapHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    providerSlug: SwapProviderId;
+    isReady: boolean;
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet: boolean);
+    get chainService(): ChainService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    getSubmitStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    private getHotkeysByNetuidDesc;
+    private buildSwapCalls;
+}