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

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/handler/hydradx-handler.js

@@ -108,7 +108,11 @@ export class HydradxHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient,
+        slippage
       },
       selectedQuote
     } = params;
@@ -127,8 +131,8 @@ export 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 = _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);
     const actionList = JSON.stringify(path.map(step => step.action));
     const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
     const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
@@ -152,7 +156,7 @@ export 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}`);
@@ -163,7 +167,7 @@ export class HydradxHandler {
       }
       const overrideQuote = quoteAskResponse.quote;
       txHex = overrideQuote.metadata;
-      receiver = _reformatAddressWithChain(params.request.address, destinationChain);
+      receiver = _reformatAddressWithChain(address, destinationChain, alternativeAddress);
     }
     if (!txHex || !isHex(txHex)) {
       return Promise.resolve(undefined);

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";
@@ -102,8 +103,7 @@ export class SwapService {
     if (!params.selectedQuote) {
       return this.getDefaultProcessV2(params);
     } else {
-      var _params$request$curre;
-      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
+      const providerId = params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         // todo: handle error response from generateOptimalProcess
@@ -128,6 +128,8 @@ export class SwapService {
     console.group('Swap Logger');
     console.log('path', path);
     console.log('swapQuoteResponse', swapQuoteResponse);
+
+    // Just to log routing type for Uniswap Quote
     if (swapQuoteResponse.optimalQuote && swapQuoteResponse.optimalQuote.metadata) {
       const routing = swapQuoteResponse.optimalQuote.metadata.routing;
       if (routing) {
@@ -146,7 +148,7 @@ export class SwapService {
     }
 
     // override fee for quote because some cases need estimate network fee on Extension (i.e. Optimex)
-    if (swapQuoteResponse.optimalQuote) {
+    if (swapQuoteResponse.optimalQuote && [SwapProviderId.OPTIMEX, SwapProviderId.OPTIMEX_TESTNET].includes(swapQuoteResponse.optimalQuote.provider.id)) {
       const swapIndex = optimalProcess.steps.findIndex(step => step.type === SwapStepType.SWAP);
       swapQuoteResponse.optimalQuote.feeInfo.feeComponent = optimalProcess.totalFee[swapIndex].feeComponent;
     }
@@ -189,7 +191,7 @@ export class SwapService {
     const swapAction = path.find(step => step.action === DynamicSwapType.SWAP);
     const directSwapRequest = swapAction ? {
       ...request,
-      address: _reformatAddressWithChain(request.address, this.chainService.getChainInfoByKey(_getAssetOriginChain(this.chainService.getAssetBySlug(swapAction.pair.from)))),
+      address: _reformatAddressWithChain(request.address, this.chainService.getChainInfoByKey(_getAssetOriginChain(this.chainService.getAssetBySlug(swapAction.pair.from))), request.alternativeAddress),
       pair: swapAction.pair
     } : undefined;
     if (!directSwapRequest) {
@@ -289,6 +291,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

@@ -1,6 +1,6 @@
-import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainAsset } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
-import { AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseStepDetail, BaseStepType, CommonOptimalSwapPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import BigN from 'bignumber.js';
 import { BaseProcessRequestSign, TransactionData } from '../transaction';
@@ -65,13 +65,14 @@ 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 {
     id: SwapProviderId;
     name: string;
-    faq?: string;
 }
 export declare enum SwapFeeType {
     PLATFORM_FEE = "PLATFORM_FEE",
@@ -99,30 +100,13 @@ export interface HydradxSwapTxData extends SwapBaseTxData {
     txHex: string;
 }
 export declare type GenSwapStepFuncV2 = (params: OptimalSwapPathParamsV2, stepIndex: number) => Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-export interface ChainflipPreValidationMetadata {
-    minSwap: AmountData;
-    maxSwap?: AmountData;
-    chain: _ChainInfo;
-}
-export interface HydradxPreValidationMetadata {
-    maxSwap: AmountData;
-    chain: _ChainInfo;
-}
-export interface AssetHubPreValidationMetadata {
-    chain: _ChainInfo;
-    toAmount: string;
-    quoteRate: string;
-    priceImpactPct?: string;
-}
-export interface SimpleSwapValidationMetadata {
-    minSwap: AmountData;
-    maxSwap: AmountData;
-    chain: _ChainInfo;
-}
 export interface ProcessedQuoteAskResponse {
     quote?: SwapQuote;
     error?: SwapError;
 }
+/**
+ * @deprecated Use interface `SwapRequestV2` instead.
+ */
 export interface SwapRequest {
     address: string;
     pair: SwapPair;
@@ -134,6 +118,7 @@ export interface SwapRequest {
 }
 export interface SwapRequestV2 {
     address: string;
+    alternativeAddress?: string;
     pair: SwapPair;
     fromAmount: string;
     slippage: number;
@@ -180,22 +165,11 @@ export interface DynamicSwapAction {
     action: DynamicSwapType;
     pair: ActionPair;
 }
-export declare const enum BridgeStepPosition {
-    FIRST = 0,
-    AFTER_SWAP = 1
-}
 export interface OptimalSwapPathParamsV2 {
-    request: SwapRequest;
+    request: SwapRequestV2;
     selectedQuote?: SwapQuote;
     path: DynamicSwapAction[];
 }
-export interface SwapEarlyValidation {
-    error?: SwapErrorType;
-    metadata?: ChainflipPreValidationMetadata | HydradxPreValidationMetadata | AssetHubPreValidationMetadata;
-}
-export interface AssetHubSwapEarlyValidation extends SwapEarlyValidation {
-    metadata: AssetHubPreValidationMetadata;
-}
 export interface ValidateSwapProcessParams {
     address: string;
     process: CommonOptimalSwapPath;

package/types/swap/index.js

@@ -1,8 +1,6 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-// core
-
 export let SwapErrorType;
 (function (SwapErrorType) {
   SwapErrorType["ERROR_FETCHING_QUOTE"] = "ERROR_FETCHING_QUOTE";
@@ -42,9 +40,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];
-// process handling
+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];
 export let SwapFeeType;
 (function (SwapFeeType) {
   SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
@@ -52,15 +51,13 @@ export let SwapFeeType;
   SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
 })(SwapFeeType || (SwapFeeType = {})); // todo: will be more
 // parameters & responses
+/**
+ * @deprecated Use interface `SwapRequestV2` instead.
+ */
 export let DynamicSwapType;
 (function (DynamicSwapType) {
   DynamicSwapType["SWAP"] = "SWAP";
   DynamicSwapType["BRIDGE"] = "BRIDGE";
 })(DynamicSwapType || (DynamicSwapType = {}));
-export let BridgeStepPosition;
-(function (BridgeStepPosition) {
-  BridgeStepPosition[BridgeStepPosition["FIRST"] = 0] = "FIRST";
-  BridgeStepPosition[BridgeStepPosition["AFTER_SWAP"] = 1] = "AFTER_SWAP";
-})(BridgeStepPosition || (BridgeStepPosition = {}));
 export const CHAINFLIP_SLIPPAGE = 0.02; // Example: 0.01 for 1%
 export const SIMPLE_SWAP_SLIPPAGE = 0.05;

package/types/yield/actions/join/step.d.ts

@@ -1,3 +1,4 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
 import { YieldPoolTarget } from '@subwallet/extension-base/types';
 /**
  * @interface RequestEarlyValidateYield
@@ -95,3 +96,9 @@ export interface OptimalYieldPath {
     connectionError?: string;
 }
 export declare type GenStepFunction = (params: OptimalYieldPathParams) => Promise<YieldStepBaseInfo | undefined>;
+export interface XcmStepMetadataForLiqStaking {
+    sendingValue: string;
+    xcmDestinationFee?: string;
+    originTokenInfo: _ChainAsset;
+    destinationTokenInfo: _ChainAsset;
+}

package/types/yield/actions/join/submit.d.ts

@@ -1,4 +1,4 @@
-import { _Address, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _Address, AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseProcessRequestSign, BaseRequestSign, InternalRequestSign, TransactionData } from '../../../transaction';
 import { BittensorRootClaimType, NominationPoolInfo, ValidatorInfo, YieldPoolType, YieldPositionInfo } from '../../info';
 import { OptimalYieldPath } from './step';
@@ -9,6 +9,8 @@ export interface HandleYieldStepData {
     chainType: ChainType;
     txData: any;
     transferNativeAmount: string;
+    xcmStepFee?: string;
+    xcmDestinationFee?: AmountData;
 }
 export interface AbstractSubmitYieldJoinData {
     slug: string;

package/utils/account/common.d.ts

@@ -3,7 +3,28 @@ import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountChainType, AccountJson } from '@subwallet/extension-base/types';
 export declare function isAccountAll(address?: string): boolean;
 export declare function reformatAddress(address: string, networkPrefix?: number, isEthereum?: boolean, ignoreError?: boolean): string;
-export declare const _reformatAddressWithChain: (address: string, chainInfo: _ChainInfo) => string;
+/**
+ * @private
+ * Reformats a wallet address based on the provided chain information.
+ *
+ * This function checks the chain type (Substrate, TON, Cardano, or others)
+ * and applies the corresponding formatting logic:
+ * 1. **Substrate**: Reformats the Substrate address using the chain's specific prefix.
+ * If the current `address` is an EVM address, it attempts to use the `alternativeAddress`
+ * (which is currently **always** expected to be the Substrate address) for Substrate
+ * formatting, as direct EVM-to-Substrate reformatting is not possible here.
+ * 2. **TON/Cardano**: Uses a simple prefix logic based on whether the chain is a testnet or a mainnet.
+ * 3. **Default (EVM/Others)**: Returns the original address without reformatting.
+ *
+ * @param address The current wallet address string.
+ * @param chainInfo An object containing chain details (e.g., chain type, testnet status, prefix).
+ * @param alternativeAddress An optional alternative address, which is currently expected to be the Substrate
+ * address associated with the account. It is used as a fallback for Substrate formatting when the main `address` is EVM.
+ * @returns The reformatted wallet address, or the original address if no reformatting is needed or possible.
+ *
+ * @todo This function currently lacks logic to reformat a Substrate address into an EVM address format.
+ */
+export declare const _reformatAddressWithChain: (address: string, chainInfo: _ChainInfo, alternativeAddress?: string) => string;
 export declare const getAccountChainTypeForAddress: (address: string) => AccountChainType;
 declare type AddressesByChainType = {
     [key in ChainType]: string[];

package/utils/account/common.js

@@ -40,17 +40,53 @@ export function reformatAddress(address, networkPrefix = 42, isEthereum = false,
     return address;
   }
 }
-export const _reformatAddressWithChain = (address, chainInfo) => {
+
+/**
+ * @private
+ * Reformats a wallet address based on the provided chain information.
+ *
+ * This function checks the chain type (Substrate, TON, Cardano, or others)
+ * and applies the corresponding formatting logic:
+ * 1. **Substrate**: Reformats the Substrate address using the chain's specific prefix.
+ * If the current `address` is an EVM address, it attempts to use the `alternativeAddress`
+ * (which is currently **always** expected to be the Substrate address) for Substrate
+ * formatting, as direct EVM-to-Substrate reformatting is not possible here.
+ * 2. **TON/Cardano**: Uses a simple prefix logic based on whether the chain is a testnet or a mainnet.
+ * 3. **Default (EVM/Others)**: Returns the original address without reformatting.
+ *
+ * @param address The current wallet address string.
+ * @param chainInfo An object containing chain details (e.g., chain type, testnet status, prefix).
+ * @param alternativeAddress An optional alternative address, which is currently expected to be the Substrate
+ * address associated with the account. It is used as a fallback for Substrate formatting when the main `address` is EVM.
+ * @returns The reformatted wallet address, or the original address if no reformatting is needed or possible.
+ *
+ * @todo This function currently lacks logic to reformat a Substrate address into an EVM address format.
+ */
+export const _reformatAddressWithChain = (address, chainInfo, alternativeAddress) => {
   const chainType = _chainInfoToAccountChainType(chainInfo);
   if (chainType === AccountChainType.SUBSTRATE) {
-    return reformatAddress(address, _getChainSubstrateAddressPrefix(chainInfo));
-  } else if (chainType === AccountChainType.TON || chainType === AccountChainType.CARDANO) {
-    const isTestnet = chainInfo.isTestnet;
-    return reformatAddress(address, isTestnet ? 0 : 1);
-  } else {
-    // EVM, Bitcoin
-    return address;
+    const addressPrefix = _getChainSubstrateAddressPrefix(chainInfo);
+    if (addressPrefix < 0) {
+      // not a valid address prefix for substrate chain type
+      return address;
+    }
+    if (isEthereumAddress(address)) {
+      if (alternativeAddress) {
+        // reformat using alternativeAddress of that account. Because can not reformat from evm address to substrate address
+        return reformatAddress(alternativeAddress, addressPrefix);
+      }
+
+      // can not reformat without substrateAddress info
+      return address;
+    }
+
+    // reformat as usual with substrate address
+    return reformatAddress(address, addressPrefix);
+  }
+  if (chainType === AccountChainType.TON || chainType === AccountChainType.CARDANO) {
+    return reformatAddress(address, chainInfo.isTestnet ? 0 : 1);
   }
+  return address;
 };
 export const getAccountChainTypeForAddress = address => {
   const type = getKeypairTypeByAddress(address);

package/utils/fee/transfer.d.ts

@@ -20,6 +20,7 @@ export interface CalculateMaxTransferable extends TransactionFee {
     isTransferNativeTokenAndPayLocalTokenAsFee: boolean;
     nativeToken: _ChainAsset;
     transferAll?: boolean;
+    metadata?: Record<string, any>;
 }
 export declare const detectTransferTxType: (srcToken: _ChainAsset, srcChain: _ChainInfo, destChain: _ChainInfo) => FeeChainType;
 export declare const calculateMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;