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

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.77-0'
+  version: '1.3.78-0'
 };

package/services/balance-service/helpers/subscribe/evm.d.ts

@@ -1,3 +1,4 @@
 import { SubscribeEvmPalletBalance } from '@subwallet/extension-base/types';
 export declare function subscribeERC20Interval({ addresses, assetMap, callback, chainInfo, evmApi }: SubscribeEvmPalletBalance): () => void;
+export declare function subscribeERC20IntervalForSubtensorEvm({ addresses, assetMap, callback, chainInfo, evmApi, substrateApiMap }: SubscribeEvmPalletBalance): () => void;
 export declare function subscribeEVMBalance(params: SubscribeEvmPalletBalance): () => void;

package/services/balance-service/helpers/subscribe/evm.js

@@ -5,9 +5,11 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
 import { ASTAR_REFRESH_BALANCE_INTERVAL, SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
 import { getERC20Contract } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { evmToSs58 } from '@subwallet/extension-base/services/balance-service/transfer/xcm/bittensorBridge/utils';
 import { _BALANCE_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetNetuid, _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
 import { BN } from '@polkadot/util';
 export function subscribeERC20Interval({
   addresses,
@@ -60,6 +62,77 @@ export function subscribeERC20Interval({
     clearInterval(interval);
   };
 }
+export function subscribeERC20IntervalForSubtensorEvm({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  evmApi,
+  substrateApiMap
+}) {
+  const chain = chainInfo.slug;
+  const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.ERC20]);
+  let cancel = false;
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        var _tokenInfo$metadata;
+        if ((_tokenInfo$metadata = tokenInfo.metadata) !== null && _tokenInfo$metadata !== void 0 && _tokenInfo$metadata.isAlphaToken && substrateApiMap) {
+          const ss58ToEvmMap = {};
+          const subtensorEvmSs58Address = [];
+          addresses.forEach(address => {
+            const ss58Address = evmToSs58(address);
+            subtensorEvmSs58Address.push(ss58Address);
+            ss58ToEvmMap[ss58Address] = address;
+          });
+          if (cancel) {
+            return;
+          }
+          const substrateApi = await substrateApiMap.bittensor.isReady;
+          const rawData = await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkeys(subtensorEvmSs58Address);
+          const values = rawData.toPrimitive();
+          const converted = {};
+          for (let i = 0; i < values.length; i++) {
+            const [, stakes] = values[i];
+            const s58Address = subtensorEvmSs58Address[i];
+            const address = ss58ToEvmMap[s58Address];
+            converted[address] = {};
+            stakes.forEach(stakeInfo => {
+              const {
+                netuid,
+                stake
+              } = stakeInfo;
+              const currentValue = converted[address][netuid] || BigN(0);
+              converted[address][netuid] = currentValue.plus(stake);
+            });
+          }
+          const netuid = _getAssetNetuid(tokenInfo);
+          const items = Object.entries(converted).map(([address, stakeMap]) => {
+            const value = stakeMap[netuid] || BigN(0);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              state: APIItemState.READY,
+              free: value.toFixed(0),
+              locked: '0'
+            };
+          });
+          if (!cancel) {
+            callback(items);
+          }
+        }
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    cancel = true;
+    clearInterval(interval);
+  };
+}
 async function getEVMBalance(addresses, web3Api) {
   return await Promise.all(addresses.map(async address => {
     try {
@@ -110,8 +183,10 @@ export function subscribeEVMBalance(params) {
   getBalance();
   const interval = setInterval(getBalance, ASTAR_REFRESH_BALANCE_INTERVAL);
   const unsub2 = subscribeERC20Interval(params);
+  const unsub3 = subscribeERC20IntervalForSubtensorEvm(params);
   return () => {
     clearInterval(interval);
     unsub2 && unsub2();
+    unsub3 && unsub3();
   };
 }

package/services/balance-service/helpers/subscribe/index.js

@@ -46,7 +46,8 @@ export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _cha
         assetMap: chainAssetMap,
         callback,
         chainInfo,
-        evmApi
+        evmApi,
+        substrateApiMap
       });
     }
     const tonApi = tonApiMap[chainSlug];

package/services/balance-service/index.js

@@ -207,12 +207,16 @@ export class BalanceService {
       const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
       let unsub = noop;
       unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
+        var _rs$lockedDetails;
         const rs = result[0];
         let value;
         switch (balanceType) {
           case BalanceType.TOTAL:
             value = new BigN(rs.free).plus(new BigN(rs.locked)).toFixed();
             break;
+          case BalanceType.STAKING:
+            value = ((_rs$lockedDetails = rs.lockedDetails) === null || _rs$lockedDetails === void 0 ? void 0 : _rs$lockedDetails.staking) || '0';
+            break;
           case BalanceType.TOTAL_MINUS_RESERVED:
             if (_BALANCE_CHAIN_GROUP.notSupportGetBalanceByType.includes(chainInfo.slug)) {
               // TODO: Currently Vara and Avail staking from nomination pools is not fully supported.
@@ -220,8 +224,8 @@ export class BalanceService {
               // Improve later when full staking breakdown is available.
               value = rs.free;
             } else {
-              var _rs$lockedDetails, _rs$lockedDetails2;
-              value = new BigN(rs.free).plus(new BigN(rs.locked)).minus(BigN.max(new BigN(((_rs$lockedDetails = rs.lockedDetails) === null || _rs$lockedDetails === void 0 ? void 0 : _rs$lockedDetails.reserved) || 0), new BigN(((_rs$lockedDetails2 = rs.lockedDetails) === null || _rs$lockedDetails2 === void 0 ? void 0 : _rs$lockedDetails2.staking) || 0))).toFixed();
+              var _rs$lockedDetails2, _rs$lockedDetails3;
+              value = new BigN(rs.free).plus(new BigN(rs.locked)).minus(BigN.max(new BigN(((_rs$lockedDetails2 = rs.lockedDetails) === null || _rs$lockedDetails2 === void 0 ? void 0 : _rs$lockedDetails2.reserved) || 0), new BigN(((_rs$lockedDetails3 = rs.lockedDetails) === null || _rs$lockedDetails3 === void 0 ? void 0 : _rs$lockedDetails3.staking) || 0))).toFixed();
             }
             break;
           default:

package/services/balance-service/transfer/token.d.ts

@@ -10,7 +10,8 @@ interface CreateTransferExtrinsicProps {
     value: string;
     transferAll: boolean;
     tokenInfo: _ChainAsset;
+    metadata?: Record<string, any>;
 }
-export declare const createSubstrateExtrinsic: ({ from, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
+export declare const createSubstrateExtrinsic: ({ from, metadata, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
 export declare const getTransferMockTxFee: (address: string, chainInfo: _ChainInfo, tokenInfo: _ChainAsset, api: _SubstrateApi | _EvmApi | _TonApi) => Promise<BigN>;
 export {};

package/services/balance-service/transfer/token.js

@@ -19,6 +19,7 @@ import { BN, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 export const createSubstrateExtrinsic = async ({
   from,
+  metadata,
   networkKey,
   substrateApi,
   to,
@@ -121,6 +122,20 @@ export const createSubstrateExtrinsic = async ({
     }
   } else if (_TRANSFER_CHAIN_GROUP.truth.includes(networkKey)) {
     transfer = api.tx.assetManager.transfer(to, _getTokenOnChainInfo(tokenInfo), value);
+  } else if (_TRANSFER_CHAIN_GROUP.bittensor.includes(networkKey) && !!metadata) {
+    const {
+      fromValidator,
+      netuid,
+      toValidator
+    } = metadata;
+    const formatToValidator = toValidator === null || toValidator === void 0 ? void 0 : toValidator.split('___')[0];
+    if (fromValidator === formatToValidator) {
+      transfer = substrateApi.api.tx.subtensorModule.transferStake(to, fromValidator, netuid, netuid, value);
+    } else {
+      const moveStakeTx = substrateApi.api.tx.subtensorModule.moveStake(fromValidator, formatToValidator, netuid, netuid, value);
+      const transferStakeTx = substrateApi.api.tx.subtensorModule.transferStake(to, formatToValidator, netuid, netuid, value);
+      transfer = substrateApi.api.tx.utility.batchAll([moveStakeTx, transferStakeTx]);
+    }
   }
   return [transfer, transferAmount || value];
 };

package/services/balance-service/transfer/xcm/bittensorBridge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nativeTokenBridge';
+export * from './utils';

package/services/balance-service/transfer/xcm/bittensorBridge/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./nativeTokenBridge.js";
+export * from "./utils.js";

package/services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge.d.ts

@@ -0,0 +1,6 @@
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { FeeCustom, FeeInfo, FeeOption } from '@subwallet/extension-base/types';
+import { TransactionConfig } from 'web3-core';
+export declare function getSubtensorEvmtoBittensorExtrinsic(sender: string, recipientAddress: string, sendingValue: string, evmApi: _EvmApi, _feeInfo: FeeInfo, feeCustom?: FeeCustom, feeOption?: FeeOption): Promise<TransactionConfig>;
+export declare function _isBittensorToSubtensorBridge(srcChain: string, destChain: string): boolean;
+export declare function _isSubtensorToBittensorBridge(srcChain: string, destChain: string): boolean;

package/services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge.js

@@ -0,0 +1,50 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { getWeb3Contract } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { combineEthFee } from '@subwallet/extension-base/utils';
+import { BN, compactToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { decodeAddress } from '@polkadot/util-crypto';
+const NATIVE_SUBTENSOR_ABI = [{
+  inputs: [{
+    internalType: 'bytes32',
+    name: 'data',
+    type: 'bytes32'
+  }],
+  name: 'transfer',
+  outputs: [],
+  stateMutability: 'payable',
+  type: 'function'
+}];
+const nativeSubtensorEvmContractAddress = '0x0000000000000000000000000000000000000800';
+export async function getSubtensorEvmtoBittensorExtrinsic(sender, recipientAddress, sendingValue, evmApi, _feeInfo, feeCustom, feeOption) {
+  const contract = getWeb3Contract(nativeSubtensorEvmContractAddress, evmApi, NATIVE_SUBTENSOR_ABI);
+  const toAccountId = decodeAddress(recipientAddress);
+  const amountSubstrate = new BN(sendingValue).div(new BN(10).pow(new BN(9)));
+  const amountU8a = compactToU8a(amountSubstrate);
+  const scaleEncoded = u8aConcat(toAccountId, amountU8a);
+  const dataU8a = scaleEncoded.slice(0, 32);
+  const dataHex = u8aToHex(dataU8a);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+  const transferCall = contract.methods.transfer(dataHex);
+  const txData = transferCall.encodeABI();
+  const feeInfo = _feeInfo;
+  const feeCombine = combineEthFee(feeInfo, feeOption, feeCustom);
+  const transactionConfig = {
+    from: sender,
+    to: nativeSubtensorEvmContractAddress,
+    value: sendingValue,
+    data: txData,
+    ...feeCombine
+  };
+  transactionConfig.gas = (await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 30000)).toString();
+  return transactionConfig;
+}
+export function _isBittensorToSubtensorBridge(srcChain, destChain) {
+  return srcChain === COMMON_CHAIN_SLUGS.BITTENSOR && destChain === COMMON_CHAIN_SLUGS.SUBTENSOR_EVM || srcChain === COMMON_CHAIN_SLUGS.BITTENSOR_TESTNET && destChain === COMMON_CHAIN_SLUGS.SUBTENSOR_EVM_TESTNET;
+}
+export function _isSubtensorToBittensorBridge(srcChain, destChain) {
+  return srcChain === COMMON_CHAIN_SLUGS.SUBTENSOR_EVM && destChain === COMMON_CHAIN_SLUGS.BITTENSOR || srcChain === COMMON_CHAIN_SLUGS.SUBTENSOR_EVM_TESTNET && destChain === COMMON_CHAIN_SLUGS.BITTENSOR_TESTNET;
+}

package/services/balance-service/transfer/xcm/bittensorBridge/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convert an EVM address (0x...) into a Substrate SS58 address
+ *
+ * @param evmAddress EVM address, with or without the "0x" prefix
+ * @param ss58Prefix SS58 network prefix (default is 42 – generic Substrate)
+ * @returns SS58-encoded Substrate address
+ */
+export declare function evmToSs58(evmAddress: string, ss58Prefix?: number): string;

package/services/balance-service/transfer/xcm/bittensorBridge/utils.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { hexToU8a } from '@polkadot/util';
+import { blake2AsU8a, encodeAddress } from '@polkadot/util-crypto';
+const EVM_PREFIX = new TextEncoder().encode('evm:');
+
+/**
+ * Convert an EVM address (0x...) into a Substrate SS58 address
+ *
+ * @param evmAddress EVM address, with or without the "0x" prefix
+ * @param ss58Prefix SS58 network prefix (default is 42 – generic Substrate)
+ * @returns SS58-encoded Substrate address
+ */
+export function evmToSs58(evmAddress, ss58Prefix = 42) {
+  // Normalize input: ensure "0x" prefix and convert to Uint8Array
+  const addressBytes = hexToU8a(evmAddress.startsWith('0x') ? evmAddress : '0x' + evmAddress);
+
+  // Build the input buffer: "evm:" prefix + 20-byte EVM address
+  const combined = new Uint8Array(EVM_PREFIX.length + addressBytes.length);
+  combined.set(EVM_PREFIX);
+  combined.set(addressBytes, EVM_PREFIX.length);
+
+  // Hash using blake2b-256 to derive a Substrate AccountId
+  const hash = blake2AsU8a(combined);
+
+  // Encode the hash into an SS58 address with the given prefix
+  return encodeAddress(hash, ss58Prefix);
+}

package/services/balance-service/transfer/xcm/index.d.ts

@@ -1,4 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { GetXcmFeeRequest } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
 import { TransactionConfig } from 'web3-core';
@@ -14,6 +15,7 @@ export declare type CreateXcmExtrinsicProps = {
     sendingValue: string;
     substrateApi?: _SubstrateApi;
     feeInfo: FeeInfo;
+    transferAll?: boolean;
 } & TransactionFee;
 export declare type FunctionCreateXcmExtrinsic = (props: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | TransactionConfig | undefined>;
 export declare const createSnowBridgeExtrinsic: ({ destinationChain, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
@@ -21,6 +23,9 @@ export declare const createAvailBridgeTxFromEth: ({ evmApi, feeCustom, feeInfo,
 export declare const createAvailBridgeExtrinsicFromAvail: ({ recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
 export declare const createPolygonBridgeExtrinsic: ({ destinationChain, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
 export declare const createXcmExtrinsicV2: (request: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | undefined>;
+export declare const getMinXcmTransferableAmount: (request: GetXcmFeeRequest) => Promise<string | undefined>;
 export declare const dryRunXcmExtrinsicV2: (request: CreateXcmExtrinsicProps, isPreview?: boolean) => Promise<boolean>;
 export declare const getXcmOriginFee: (request: CreateXcmExtrinsicProps) => Promise<string | undefined>;
 export declare const createAcrossBridgeExtrinsic: ({ destinationChain, destinationTokenInfo, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
+export declare const createBittensorToSubtensorEvmExtrinsic: ({ destinationChain, originChain, recipient, sendingValue, substrateApi, transferAll }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
+export declare const createSubtensorEvmToBittensorExtrinsic: ({ destinationChain, evmApi, feeCustom, feeInfo, feeOption, originChain, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;

package/services/balance-service/transfer/xcm/index.js

@@ -1,13 +1,14 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { _isAcrossBridgeXcm, _isPolygonBridgeXcm, _isPosBridgeXcm, _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { _isAcrossBridgeXcm, _isBittensorToSubtensorEvmBridge, _isPolygonBridgeXcm, _isPosBridgeXcm, _isSnowBridgeXcm, _isSubtensorEvmtoBittensorBridge } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { getAvailBridgeExtrinsicFromAvail, getAvailBridgeTxFromEth } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { _createPolygonBridgeL1toL2Extrinsic, _createPolygonBridgeL2toL1Extrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { getSnowBridgeEvmTransfer } from '@subwallet/extension-base/services/balance-service/transfer/xcm/snowBridge';
-import { buildXcm, dryRunPreviewXcm, dryRunXcm, estimateXcmFee, isChainNotSupportDryRun, isChainNotSupportPolkadotApi } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
+import { buildXcm, dryRunPreviewXcm, dryRunXcm, estimateXcmFee, fetchMinXcmTransferableAmount, isChainNotSupportDryRun, isChainNotSupportPolkadotApi } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { combineEthFee } from '@subwallet/extension-base/utils';
 import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+import { evmToSs58, getSubtensorEvmtoBittensorExtrinsic } from "./bittensorBridge/index.js";
 import { _createPosBridgeL1toL2Extrinsic, _createPosBridgeL2toL1Extrinsic } from "./posBridge.js";
 // SnowBridge
 export const createSnowBridgeExtrinsic = async ({
@@ -96,6 +97,13 @@ export const createXcmExtrinsicV2 = async request => {
     return undefined;
   }
 };
+export const getMinXcmTransferableAmount = async request => {
+  try {
+    return await fetchMinXcmTransferableAmount(request);
+  } catch (e) {
+    return undefined;
+  }
+};
 export const dryRunXcmExtrinsicV2 = async (request, isPreview = false) => {
   try {
     const dryRunResult = isPreview ? await dryRunPreviewXcm(request) : await dryRunXcm(request);
@@ -195,4 +203,51 @@ export const createAcrossBridgeExtrinsic = async ({
     }
     return Promise.reject(new Error(error === null || error === void 0 ? void 0 : error.message));
   }
+};
+
+// Native bittensor <-> subtensor EVM bridge
+
+export const createBittensorToSubtensorEvmExtrinsic = async ({
+  destinationChain,
+  originChain,
+  recipient,
+  sendingValue,
+  substrateApi,
+  transferAll
+}) => {
+  if (!_isBittensorToSubtensorEvmBridge(originChain, destinationChain)) {
+    throw new Error('This is not a valid Bittensor bridge transfer');
+  }
+  if (!substrateApi) {
+    throw Error('Substrate API is not available');
+  }
+  const api = substrateApi.api;
+  await api.isReady;
+  const subtensorEvmAddress = evmToSs58(recipient);
+  if (transferAll) {
+    return api.tx.balances.transferAll(subtensorEvmAddress, false);
+  }
+  return api.tx.balances.transferKeepAlive(subtensorEvmAddress, sendingValue);
+};
+export const createSubtensorEvmToBittensorExtrinsic = async ({
+  destinationChain,
+  evmApi,
+  feeCustom,
+  feeInfo,
+  feeOption,
+  originChain,
+  recipient,
+  sender,
+  sendingValue
+}) => {
+  if (!_isSubtensorEvmtoBittensorBridge(originChain, destinationChain)) {
+    throw new Error('This is not a valid Subtensor EVM bridge transfer');
+  }
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
+  return getSubtensorEvmtoBittensorExtrinsic(sender, recipient, sendingValue, evmApi, feeInfo, feeCustom, feeOption);
 };

package/services/balance-service/transfer/xcm/utils.d.ts

@@ -21,7 +21,7 @@ export declare type DryRunResult = {
     destination?: DryRunNodeResult;
     hops: THopInfo[];
 };
-interface GetXcmFeeRequest {
+export interface GetXcmFeeRequest {
     sender: string;
     recipient: string;
     value: string;
@@ -44,6 +44,7 @@ export declare function buildXcm(request: CreateXcmExtrinsicProps): Promise<Subm
 export declare function dryRunXcm(request: CreateXcmExtrinsicProps): Promise<DryRunResult>;
 export declare function dryRunPreviewXcm(request: CreateXcmExtrinsicProps): Promise<DryRunResult>;
 export declare function estimateXcmFee(request: GetXcmFeeRequest): Promise<GetXcmFeeResult | undefined>;
+export declare function fetchMinXcmTransferableAmount(request: GetXcmFeeRequest): Promise<string>;
 export declare function isChainNotSupportPolkadotApi(str: string): boolean;
 export declare function isChainNotSupportDryRun(str: string): boolean;
-export {};
+export declare function isSubstrateCrossChain(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo): boolean;

package/services/balance-service/transfer/xcm/utils.js

@@ -2,16 +2,25 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fetchParaSpellChainMap } from '@subwallet/extension-base/constants/paraspell-chain-map';
+import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { _isAcrossChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
+import { _isPolygonChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
+import { _isPosChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
+import { _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
 import { fetchFromProxyService } from '@subwallet/extension-base/utils';
 import BigNumber from 'bignumber.js';
 import { assert, compactToU8a, isHex, u8aConcat, u8aEq } from '@polkadot/util';
+import { _isBittensorToSubtensorBridge, _isSubtensorToBittensorBridge } from "./bittensorBridge/index.js";
 const version = '/v5';
 const paraSpellApi = {
   buildXcm: `${version}/x-transfer`,
   feeXcm: `${version}/xcm-fee`,
   dryRunXcm: `${version}/dry-run`,
-  dryRunPreviewXcm: `${version}/dry-run-preview`
+  dryRunPreviewXcm: `${version}/dry-run-preview`,
+  maxTransferable: `${version}/transferable-amount`,
+  minTransferable: `${version}/min-transferable-amount`
 };
 function txHexToSubmittableExtrinsic(api, hex) {
   try {
@@ -240,6 +249,41 @@ export async function estimateXcmFee(request) {
   }
   return await response.json();
 }
+export async function fetchMinXcmTransferableAmount(request) {
+  var _originTokenInfo$meta4;
+  const {
+    fromChainInfo: originChain,
+    fromTokenInfo: originTokenInfo,
+    recipient,
+    sender,
+    toChainInfo: destinationChain,
+    value: sendingValue
+  } = request;
+  const paraSpellChainMap = await fetchParaSpellChainMap();
+  const paraSpellIdentifyV4 = (_originTokenInfo$meta4 = originTokenInfo.metadata) === null || _originTokenInfo$meta4 === void 0 ? void 0 : _originTokenInfo$meta4.paraSpellIdentifyV4;
+  if (!paraSpellIdentifyV4) {
+    throw new Error('Token is not support XCM at this time');
+  }
+  const bodyData = {
+    senderAddress: sender,
+    address: recipient,
+    from: paraSpellChainMap[originChain.slug],
+    to: paraSpellChainMap[destinationChain.slug],
+    currency: createParaSpellCurrency(paraSpellIdentifyV4, sendingValue),
+    options: {
+      abstractDecimals: false
+    }
+  };
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.minTransferable, {
+    method: 'POST',
+    body: JSON.stringify(bodyData),
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    }
+  });
+  return await response.json();
+}
 function createParaSpellCurrency(paraSpellIdentifyV4, amount) {
   return {
     ...paraSpellIdentifyV4,
@@ -255,4 +299,46 @@ export function isChainNotSupportDryRun(str) {
   const regex = /(?=.*DryRunApi)(?=.*not available).*/i; // Example: DryRunApi is not available on node Acala
 
   return regex.test(str);
+}
+export function isSubstrateCrossChain(originChainInfo, destinationChainInfo) {
+  if (originChainInfo.slug === destinationChainInfo.slug) {
+    return false;
+  }
+
+  // isAvailBridgeFromEvm
+  if (_isPureEvmChain(originChainInfo) && isAvailChainBridge(destinationChainInfo.slug)) {
+    return false;
+  }
+
+  // isAvailBridgeFromAvail
+  if (isAvailChainBridge(originChainInfo.slug) && _isPureEvmChain(destinationChainInfo)) {
+    return false;
+  }
+
+  // isSnowBridgeEvmTransfer
+  if (_isPureEvmChain(originChainInfo) && _isSnowBridgeXcm(originChainInfo, destinationChainInfo)) {
+    return false;
+  }
+
+  // isPolygonBridgeTransfer
+  if (_isPolygonChainBridge(originChainInfo.slug, destinationChainInfo.slug)) {
+    return false;
+  }
+
+  // isPosBridgeTransfer
+  if (_isPosChainBridge(originChainInfo.slug, destinationChainInfo.slug)) {
+    return false;
+  }
+
+  // isAcrossBridgeTransfer
+  if (_isAcrossChainBridge(originChainInfo.slug, destinationChainInfo.slug)) {
+    return false;
+  }
+  if (_isBittensorToSubtensorBridge(originChainInfo.slug, destinationChainInfo.slug)) {
+    return false;
+  }
+  if (_isSubtensorToBittensorBridge(originChainInfo.slug, destinationChainInfo.slug)) {
+    return false;
+  }
+  return true;
 }

package/services/chain-service/constants.d.ts

@@ -30,6 +30,7 @@ export declare const _BALANCE_CHAIN_GROUP: {
     bittensor: string[];
     moonbeam: string[];
     notSupportGetBalanceByType: string[];
+    subtensor_evm: string[];
 };
 export declare const _BALANCE_LOCKED_ID_GROUP: {
     staking: string[];
@@ -81,6 +82,7 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     centrifuge: string[];
     disable_transfer: string[];
     truth: string[];
+    bittensor: string[];
 };
 export declare const USE_MULTILOCATION_INDEX: string[];
 export declare const _MANTA_ZK_CHAIN_GROUP: string[];

package/services/chain-service/constants.js

@@ -43,7 +43,8 @@ export const _BALANCE_CHAIN_GROUP = {
   supportBridged: ['rococo_assethub', 'statemint', 'statemine', 'polimec'],
   bittensor: ['bittensor', 'bittensor_testnet'],
   moonbeam: ['moonbeam', 'moonriver', 'moonbase'],
-  notSupportGetBalanceByType: ['vara_network', 'vara_testnet', 'availTuringTest', 'avail_mainnet']
+  notSupportGetBalanceByType: ['vara_network', 'vara_testnet', 'availTuringTest', 'avail_mainnet'],
+  subtensor_evm: ['subtensor_evm']
 };
 export const _BALANCE_LOCKED_ID_GROUP = {
   staking: ['staking', 'delegatedStaking', 'pooledStaking', 'stkngdel', 'stk_stks', 'dappStaking', 'parachainStaking', 'appstakeappstake', 'collatorStaking'],
@@ -296,7 +297,8 @@ export const _TRANSFER_CHAIN_GROUP = {
   pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot', 'jamton', 'hydradx_hollarnet'],
   centrifuge: ['centrifuge'],
   disable_transfer: ['crab', 'pangolin'],
-  truth: ['truth_network']
+  truth: ['truth_network'],
+  bittensor: ['bittensor', 'bittensor_testnet']
 };
 export const USE_MULTILOCATION_INDEX = ['energy_web_x'];
 export const _MANTA_ZK_CHAIN_GROUP = ['calamari'];

package/services/chain-service/utils/patch.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-export declare const ChainListVersion = "0.2.126";
+export declare const ChainListVersion = "0.2.127";
 export interface PatchInfo {
     patchVersion: string;
     appliedVersion: string;

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev');
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-export const ChainListVersion = '0.2.126'; // update this when build chain-list
+export const ChainListVersion = '0.2.127'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 

package/services/earning-service/constants/chains.d.ts

@@ -26,3 +26,4 @@ export declare const MANTA_VALIDATOR_POINTS_PER_BLOCK = 20;
 export declare const MANTA_MIN_DELEGATION = 500;
 export declare const CHANNEL_ID = 7;
 export declare const STAKING_IDENTITY_API_SLUG: Record<string, string>;
+export declare const MIN_XCM_LIQUID_STAKING_DOT = "15000000000";

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/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]>;