@subwallet/extension-base 1.3.77-0 → 1.3.78-0

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,51 @@ 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,
+            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 +295,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 +336,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 +373,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 +387,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 +417,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 +452,25 @@ 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
+    } = 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 +486,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 +495,9 @@ 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
     };
   }
   handleYieldJoin(data, path, currentStep) {
@@ -491,8 +509,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/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;
+}

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

@@ -0,0 +1,189 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain, toBNString } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
+import { _getAssetDecimals, _isNativeTokenBySlug } from "../../chain-service/utils/index.js";
+import { SwapBaseHandler } from "./base-handler.js";
+export class BittensorSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, feeService, isTestnet) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Bittensor Testnet' : 'Bittensor',
+      providerSlug: isTestnet ? SwapProviderId.BITTENSOR_TESTNET : SwapProviderId.BITTENSOR
+    });
+    this.providerSlug = isTestnet ? SwapProviderId.BITTENSOR_TESTNET : 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: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _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 (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case 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 = _isNativeTokenBySlug(fromAsset.slug) ? 0 : (_fromAsset$metadata = fromAsset.metadata) === null || _fromAsset$metadata === void 0 ? void 0 : _fromAsset$metadata.netuid;
+    const toNetuid = _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(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(toBNString(quote.rate, _getAssetDecimals(fromAsset)));
+    const limitPrice = priceRatio.multipliedBy(new BigNumber(1).minus(params.slippage)).integerValue(BigNumber.ROUND_DOWN).toFixed();
+    const calls = this.buildSwapCalls({
+      stakeInfo,
+      fromNetuid,
+      toNetuid,
+      amount: new BigNumber(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: ExtrinsicType.SWAP,
+      chainType: 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(i.stake).gt(0)).sort((a, b) => new BigNumber(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(item.stake);
+      if (stake.lte(0)) {
+        continue;
+      }
+      const swapAmount = BigNumber.minimum(stake, remaining);
+      calls.push(api.tx.subtensorModule.swapStakeLimit(item.hotkey, fromNetuid, toNetuid, swapAmount.toFixed(), limitPrice, false));
+      remaining = remaining.minus(swapAmount);
+    }
+    return calls;
+  }
+}

package/services/swap-service/index.js

@@ -20,6 +20,7 @@ import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
+import { BittensorSwapHandler } from "./handler/bittensor-handler.js";
 import { KyberHandler } from "./handler/kyber-handler.js";
 import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
 import { UniswapHandler } from "./handler/uniswap-handler.js";
@@ -289,6 +290,12 @@ export class SwapService {
         case SwapProviderId.OPTIMEX_TESTNET:
           this.handlers[providerId] = new OptimexHandler(this.chainService, this.state.balanceService, this.state.feeService, true);
           break;
+        case SwapProviderId.BITTENSOR:
+          this.handlers[providerId] = new BittensorSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, false);
+          break;
+        case SwapProviderId.BITTENSOR_TESTNET:
+          this.handlers[providerId] = new BittensorSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, true);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/services/transaction-service/index.js

@@ -930,6 +930,7 @@ export default class TransactionService {
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
       processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId,
+      crossChainFeeInfo: transaction === null || transaction === void 0 ? void 0 : transaction.xcmDestinationFee,
       substrateProxyAddresses: []
     };
     const substrateProxyHistories = [];

package/services/transaction-service/types.d.ts

@@ -1,4 +1,4 @@
-import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
+import { AmountData, ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { SignTypedDataMessageV3V4 } from '@subwallet/extension-base/core/logic-validation';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
 import { UniswapOrderInfo } from '@subwallet/extension-base/services/swap-service/handler/uniswap-handler';
@@ -23,6 +23,7 @@ export interface SWTransactionBase extends ValidateTransactionResponse, Partial<
     updatedAt: number;
     estimateFee?: FeeData;
     xcmFeeDryRun?: string;
+    xcmDestinationFee?: AmountData;
     transaction: any;
     additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
     eventsHandler?: (eventEmitter: TransactionEmitter) => void;
@@ -75,7 +76,7 @@ export interface SWTransactionEmitter {
     emitterTransaction?: TransactionEmitter;
 }
 declare type SwInputBase = Pick<SWTransactionBase, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransactionBase, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun' | 'wrappingStatus'>>, TransactionFee {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun' | 'xcmDestinationFee' | 'wrappingStatus'>>, TransactionFee {
     id?: string;
     transaction?: SWTransactionBase['transaction'] | null;
     warnings?: SWTransactionBase['warnings'];
@@ -94,7 +95,7 @@ export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'tran
 export interface SWDutchTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
     transaction?: SWDutchTransaction['transaction'] | null;
 }
-export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun' | 'wrappingStatus'>> & TransactionFee & {
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun' | 'xcmDestinationFee' | 'wrappingStatus'>> & TransactionFee & {
     processId?: string;
 };
 export declare type BitcoinTransactionData = {

package/types/balance/index.d.ts

@@ -12,7 +12,8 @@ export declare enum BalanceType {
     TRANSFERABLE = "transferable",
     TOTAL = "total",
     TOTAL_MINUS_RESERVED = "totalMinusReserved",
-    KEEP_ALIVE = "keepAlive"
+    KEEP_ALIVE = "keepAlive",
+    STAKING = "staking"
 }
 /**
  * Balance info of a token on an address
@@ -62,6 +63,7 @@ export interface SubscribeSubstratePalletBalance extends SubscribeBasePalletBala
 }
 export interface SubscribeEvmPalletBalance extends SubscribeBasePalletBalance {
     evmApi: _EvmApi;
+    substrateApiMap?: Record<string, _SubstrateApi>;
 }
 export interface SubscribeTonPalletBalance extends SubscribeBasePalletBalance {
     tonApi: _TonApi;

package/types/balance/index.js

@@ -18,6 +18,7 @@ export let BalanceType;
   BalanceType["TOTAL"] = "total";
   BalanceType["TOTAL_MINUS_RESERVED"] = "totalMinusReserved";
   BalanceType["KEEP_ALIVE"] = "keepAlive";
+  BalanceType["STAKING"] = "staking";
 })(BalanceType || (BalanceType = {}));
 /** Balance info of all tokens on an address */
 // Key is tokenSlug

package/types/balance/transfer.d.ts

@@ -9,6 +9,7 @@ export interface RequestSubscribeTransfer extends TransactionFee {
     token: string;
     destChain: string;
     transferAll?: boolean;
+    metadata?: Record<string, any>;
 }
 export interface ResponseSubscribeTransfer {
     id: string;
@@ -26,6 +27,11 @@ export interface RequestSubmitTransferWithId extends RequestSubmitTransfer {
 export interface ResponseSubscribeTransferConfirmation extends Omit<ResponseSubscribeTransfer, 'maxTransferable'> {
     error?: string;
 }
+export interface AlphaTokenTransferMetadata {
+    netuid: number;
+    fromValidator: string;
+    toValidator: string;
+}
 export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     chain: string;
     from: string;
@@ -37,6 +43,7 @@ export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     isSubstrateECDSATransaction?: boolean;
     maxTransferableWithoutFee?: string;
     maxTransferable?: string;
+    metadata?: Record<string, any>;
 }
 export interface RequestSubmitSignPsbtTransfer extends BaseRequestSign {
     id: string;

package/types/fee/base.d.ts

@@ -5,6 +5,7 @@ export interface BaseFeeInfo {
 }
 export interface BaseFeeDetail {
     estimatedFee: string;
+    crossChainFee?: string;
 }
 export interface BaseFeeTime {
     time: number;

package/types/swap/index.d.ts

@@ -65,7 +65,9 @@ export declare enum SwapProviderId {
     UNISWAP = "UNISWAP",
     KYBER = "KYBER",
     OPTIMEX = "OPTIMEX",
-    OPTIMEX_TESTNET = "OPTIMEX_TESTNET"
+    OPTIMEX_TESTNET = "OPTIMEX_TESTNET",
+    BITTENSOR = "BITTENSOR",
+    BITTENSOR_TESTNET = "BITTENSOR_TESTNET"
 }
 export declare const _SUPPORTED_SWAP_PROVIDERS: SwapProviderId[];
 export interface SwapProvider {

package/types/swap/index.js

@@ -42,8 +42,10 @@ export let SwapProviderId;
   SwapProviderId["KYBER"] = "KYBER";
   SwapProviderId["OPTIMEX"] = "OPTIMEX";
   SwapProviderId["OPTIMEX_TESTNET"] = "OPTIMEX_TESTNET";
+  SwapProviderId["BITTENSOR"] = "BITTENSOR";
+  SwapProviderId["BITTENSOR_TESTNET"] = "BITTENSOR_TESTNET";
 })(SwapProviderId || (SwapProviderId = {}));
-export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP, SwapProviderId.KYBER, SwapProviderId.OPTIMEX, SwapProviderId.OPTIMEX_TESTNET];
+export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP, SwapProviderId.KYBER, SwapProviderId.OPTIMEX, SwapProviderId.OPTIMEX_TESTNET, SwapProviderId.BITTENSOR, SwapProviderId.BITTENSOR_TESTNET];
 // process handling
 export let SwapFeeType;
 (function (SwapFeeType) {