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

package/koni/background/handlers/Extension.js

@@ -8,6 +8,7 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
 import { CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
 import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, BTC_DUST_AMOUNT, LATEST_SESSION } from '@subwallet/extension-base/constants';
 import { additionalValidateTransferForRecipient, validateTransferRequest, validateXcmMinAmountToMythos, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
@@ -31,9 +32,10 @@ import { createCardanoTransaction } from '@subwallet/extension-base/services/bal
 import { getERC20TransactionObject, getERC721Transaction, getEVMTransactionObject, getPSP34TransferExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
 import { createTonTransaction } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { createAcrossBridgeExtrinsic, createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createAcrossBridgeExtrinsic, createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createBittensorToSubtensorEvmExtrinsic, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createSubtensorEvmToBittensorExtrinsic, createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _isAcrossChainBridge, getAcrossQuote } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { getClaimTxOnAvail, getClaimTxOnEthereum, isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
+import { _isBittensorToSubtensorBridge, _isSubtensorToBittensorBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge';
 import { _isPolygonChainBridge, getClaimPolygonBridge, isClaimedPolygonBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
 import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
@@ -1258,6 +1260,7 @@ export default class KoniExtension {
       feeCustom,
       feeOption,
       from,
+      metadata,
       to,
       tokenPayFeeSlug,
       tokenSlug,
@@ -1398,7 +1401,8 @@ export default class KoniExtension {
           networkKey: chain,
           tokenInfo: transferTokenInfo,
           to: to,
-          substrateApi
+          substrateApi,
+          metadata
         });
         if (_SUPPORT_TOKEN_PAY_FEE_GROUP.hydration.includes(chain)) {
           var _this$koniState$chain, _substrateApi$api$que;
@@ -1525,11 +1529,18 @@ export default class KoniExtension {
     const isPolygonBridgeTransfer = _isPolygonChainBridge(originNetworkKey, destinationNetworkKey);
     const isPosBridgeTransfer = _isPosChainBridge(originNetworkKey, destinationNetworkKey);
     const isAcrossBridgeTransfer = _isAcrossChainBridge(originNetworkKey, destinationNetworkKey);
+    const isBittensorBridgeTransfer = _isBittensorToSubtensorBridge(originNetworkKey, destinationNetworkKey);
+    const isSubtensorEvmBridgeTransfer = _isSubtensorToBittensorBridge(originNetworkKey, destinationNetworkKey);
     const extrinsicType = ExtrinsicType.TRANSFER_XCM;
-    const isSubstrateXcm = !(isAvailBridgeFromEvm || isAvailBridgeFromAvail || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer || isAcrossBridgeTransfer);
+    const isSubstrateParaspellXcm = !(isAvailBridgeFromEvm || isAvailBridgeFromAvail || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer || isAcrossBridgeTransfer || isBittensorBridgeTransfer || isSubtensorEvmBridgeTransfer);
     const isTransferNative = this.#koniState.getNativeTokenInfo(originNetworkKey).slug === tokenSlug;
     const isTransferLocalTokenAndPayThatTokenAsFee = !isTransferNative && tokenSlug === tokenPayFeeSlug;
     let xcmFeeDryRun;
+    const xcmDestinationFee = {
+      symbol: (destinationTokenInfo === null || destinationTokenInfo === void 0 ? void 0 : destinationTokenInfo.symbol) || '',
+      decimals: (destinationTokenInfo === null || destinationTokenInfo === void 0 ? void 0 : destinationTokenInfo.decimals) || 0,
+      value: '0'
+    };
     let additionalValidator;
     let eventsHandler;
     if (fromKeyPair && destinationTokenInfo) {
@@ -1540,6 +1551,9 @@ export default class KoniExtension {
       if (isPosBridgeTransfer || isPolygonBridgeTransfer) {
         funcCreateExtrinsic = createPolygonBridgeExtrinsic;
         type = 'evm';
+      } else if (isSubtensorEvmBridgeTransfer) {
+        funcCreateExtrinsic = createSubtensorEvmToBittensorExtrinsic;
+        type = 'evm';
       } else if (isAcrossBridgeTransfer) {
         funcCreateExtrinsic = createAcrossBridgeExtrinsic;
         type = 'evm';
@@ -1549,6 +1563,9 @@ export default class KoniExtension {
       } else if (isAvailBridgeFromEvm) {
         funcCreateExtrinsic = createAvailBridgeTxFromEth;
         type = 'evm';
+      } else if (isBittensorBridgeTransfer) {
+        funcCreateExtrinsic = createBittensorToSubtensorEvmExtrinsic;
+        type = 'substrate';
       } else if (isAvailBridgeFromAvail) {
         funcCreateExtrinsic = createAvailBridgeExtrinsicFromAvail;
         type = 'substrate';
@@ -1569,10 +1586,11 @@ export default class KoniExtension {
         evmApi,
         feeCustom,
         feeOption,
-        feeInfo
+        feeInfo,
+        transferAll
       };
       extrinsic = await funcCreateExtrinsic(params);
-      if (isSubstrateXcm) {
+      if (isSubstrateParaspellXcm) {
         const xcmFeeInfo = await estimateXcmFee({
           fromChainInfo: params.originChain,
           fromTokenInfo: params.originTokenInfo,
@@ -1581,7 +1599,11 @@ export default class KoniExtension {
           sender: params.sender,
           value: params.sendingValue
         });
+
+        // todo: refactor name
+        // todo: check to use full interface to has full AmountData, include symbol, decimal
         xcmFeeDryRun = (xcmFeeInfo === null || xcmFeeInfo === void 0 ? void 0 : xcmFeeInfo.origin.fee) || '0';
+        xcmDestinationFee.value = (xcmFeeInfo === null || xcmFeeInfo === void 0 ? void 0 : xcmFeeInfo.destination.fee) || '0';
       }
       if (isAcrossBridgeTransfer) {
         const data = await getAcrossQuote(params);
@@ -1649,7 +1671,7 @@ export default class KoniExtension {
           warning.length && inputTransaction.warnings.push(...warning);
           error.length && inputTransaction.errors.push(...error);
         }
-        if (isSubstrateXcm) {
+        if (isSubstrateParaspellXcm) {
           const isDryRunSuccess = await dryRunXcmExtrinsicV2(params, false);
           if (!isDryRunSuccess) {
             inputTransaction.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again'));
@@ -1687,7 +1709,7 @@ export default class KoniExtension {
       transaction: extrinsic,
       data: inputData,
       extrinsicType,
-      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm && !isPolygonBridgeTransfer && !isPosBridgeTransfer && !isAcrossBridgeTransfer ? ChainType.SUBSTRATE : ChainType.EVM,
+      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm && !isPolygonBridgeTransfer && !isPosBridgeTransfer && !isAcrossBridgeTransfer && !isSubtensorEvmBridgeTransfer ? ChainType.SUBSTRATE : ChainType.EVM,
       transferNativeAmount: _isNativeToken(originTokenInfo) ? value : '0',
       ignoreWarnings,
       tokenPayFeeSlug,
@@ -1695,6 +1717,7 @@ export default class KoniExtension {
       isTransferLocalTokenAndPayThatTokenAsFee,
       isPassConfirmation,
       xcmFeeDryRun,
+      xcmDestinationFee,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -2158,6 +2181,7 @@ export default class KoniExtension {
       destChain: _destChain,
       feeCustom,
       feeOption,
+      metadata,
       to,
       token,
       tokenPayFeeSlug,
@@ -2199,7 +2223,8 @@ export default class KoniExtension {
       isTransferLocalTokenAndPayThatTokenAsFee,
       isTransferNativeTokenAndPayLocalTokenAsFee,
       nativeToken,
-      transferAll: transferAll
+      transferAll,
+      metadata
     };
     const subscription = combineLatest({
       freeBalance: freeBalanceSubject,
@@ -3153,8 +3178,134 @@ export default class KoniExtension {
     });
   }
 
+  // Helper for prepareMultisigSignRequest: reconstruct the original extrinsic from the payload's method & args
+  async buildExtrinsicFromPayload(chain, payload) {
+    const substrateApi = await this.#koniState.chainService.getSubstrateApi(chain).isReady;
+    const call = substrateApi.api.createType('Call', payload.method);
+    const {
+      method,
+      section
+    } = substrateApi.api.registry.findMetaCall(call.callIndex);
+    const extrinsic = substrateApi.api.tx[section][method](...call.args);
+    return {
+      substrateApi,
+      extrinsic,
+      call
+    };
+  }
+
+  /**
+   * ─────────────────────────────────────────────────────────────
+   * prepareMultisigSignRequest
+   * ─────────────────────────────────────────────────────────────
+   * Called when a dApp sends a signing request to a multisig account.
+   * This method wraps the original extrinsic into a multisig.asMulti call so that it can be submitted by one of the signers on behalf of the multisig account.
+   *
+   * Important:
+   *  - The original sign request is MUTATED in-place via updateSignRequest.
+   *    After this method returns, the UI will prompt the signer to sign
+   *    the wrapped multisig extrinsic, not the original one.
+   *  - Errors are collected (not thrown) and returned in the response
+   *    so the UI can display them without crashing.
+   *  - This method does NOT submit the transaction; it only prepares
+   *    the payload for signing.
+   * ─────────────────────────────────────────────────────────────
+   */
+  async prepareMultisigSignRequest(request) {
+    const {
+      id,
+      signer
+    } = request;
+
+    // ── Step 1: Retrieve the pending sign request from the queue ──
+    const queued = this.#koniState.getSignRequest(id);
+    assert(queued, t('bg.koni.handler.Extension.unableToProceed'));
+    const errors = [];
+    let submittedCallData = '';
+    let callData = '';
+    let depositAmount = '';
+    let networkFee = '';
+    const payload = queued.request.payload;
+
+    // ── Step 2: Validate payload format ──
+    // Only JSON payloads (SignerPayloadJSON) contain the structured fields
+    // (genesisHash, method, etc.) needed to reconstruct the extrinsic.
+    // Raw (bytes) payloads cannot be wrapped into a multisig call.
+    if (!isJsonPayload(payload)) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.koni.handler.Extension.unableToProceed')));
+    } else {
+      var _chainInfo$substrateI;
+      // ── Step 3: Resolve chain from genesisHash & check multisig support ──
+      callData = payload.method;
+      const [chain, chainInfo] = this.#koniState.findNetworkKeyByGenesisHash(payload.genesisHash);
+      if (!chain || !(chainInfo !== null && chainInfo !== void 0 && (_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig)) {
+        errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('bg.koni.handler.Extension.unableToProceed')));
+      } else {
+        // ── Step 4: Look up multisig account configuration ──
+        // queued.address is the multisig account address (the "from" in the original request).
+        // We need its threshold and signers list to construct the asMulti call.
+        const accountProxy = this.#koniState.keyringService.context.getMultisigAccountByAddress(queued.address);
+        if (!accountProxy) {
+          errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('bg.koni.handler.Extension.unableToProceed')));
+        } else {
+          const threshold = accountProxy.accounts[0].threshold;
+          const signers = accountProxy.accounts[0].signers;
+
+          // ── Step 5: Rebuild the original extrinsic from payload call data ──
+          const {
+            extrinsic: originExtrinsic,
+            substrateApi
+          } = await this.buildExtrinsicFromPayload(chain, payload);
+
+          // ── Step 6: Wrap into multisig initiation extrinsic ──
+          const multisigExtrinsic = createInitMultisigExtrinsic(substrateApi.api, threshold, signers, signer, originExtrinsic);
+
+          // ── Step 7: Estimate fee & calculate multisig deposit ──
+          submittedCallData = multisigExtrinsic.method.toHex();
+          networkFee = (await multisigExtrinsic.paymentInfo(signer)).partialFee.toString();
+          const depositBase = substrateApi.api.consts.multisig.depositBase.toString();
+          const depositFactor = substrateApi.api.consts.multisig.depositFactor.toString();
+          depositAmount = calcDepositAmount(depositBase, threshold, depositFactor);
+
+          // ── Step 8: Validate signer has sufficient balance ──
+          const signerBalance = await this.getAddressTransferableBalance({
+            address: signer,
+            networkKey: chain,
+            token: this.#koniState.chainService.getNativeTokenInfo(chain).slug,
+            extrinsicType: ExtrinsicType.TRANSFER_TOKEN
+          });
+          const requiredBalance = new BigN(depositAmount).plus(networkFee);
+          if (new BigN(signerBalance.value).lt(requiredBalance)) {
+            errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t('bg.koni.handler.Extension.notEnoughBalanceForMultisigDepositAndFee')));
+          }
+
+          // ── Step 9: Replace the original sign request with the wrapped payload ──
+          // After this, the signing UI will show the multisig extrinsic instead of
+          // the original one. The signer's address and fresh nonce are used so
+          // the transaction is submitted from the signer (not the multisig account).
+          const nonce = await substrateApi.api.rpc.system.accountNextIndex(signer);
+          const wrappedPayload = {
+            ...payload,
+            address: signer,
+            nonce: nonce.toHex(),
+            method: multisigExtrinsic.method.toHex()
+          };
+          this.#koniState.requestService.updateSignRequest(id, new RequestExtrinsicSign(wrappedPayload), signer);
+        }
+      }
+    }
+    return {
+      submittedCallData: submittedCallData,
+      callData: callData,
+      depositAmount,
+      networkFee,
+      errors
+    };
+  }
+
   // Substrate Proxy Account
   async handleSubstrateProxyWrappedTx(request) {
+    var _originTransaction;
     const {
       chain,
       proxyMetadata,
@@ -3171,8 +3322,8 @@ export default class KoniExtension {
      * ─────────────────────────────
      */
     const substrateApi = await this.#koniState.chainService.getSubstrateApi(chain).isReady;
-    const originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
-    const extrinsicOriginTransaction = originTransaction === null || originTransaction === void 0 ? void 0 : originTransaction.transaction;
+    let originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
+    const extrinsicOriginTransaction = (_originTransaction = originTransaction) === null || _originTransaction === void 0 ? void 0 : _originTransaction.transaction;
     const callData = extrinsicOriginTransaction.method.toHex();
     const decodedCallData = decodeCallData({
       api: substrateApi.api,
@@ -3244,7 +3395,8 @@ export default class KoniExtension {
      * update history transaction accordingly.
      */
     const eventsHandler = eventEmitter => {
-      if (!(originTransaction !== null && originTransaction !== void 0 && originTransaction.emitterTransaction)) {
+      var _originTransaction2;
+      if (!((_originTransaction2 = originTransaction) !== null && _originTransaction2 !== void 0 && _originTransaction2.emitterTransaction)) {
         return;
       }
       const originEmitter = originTransaction.emitterTransaction;
@@ -3296,6 +3448,49 @@ export default class KoniExtension {
      * ─────────────────────────────
      */
 
+    const originTransferData = originTransaction.data;
+    const isTransferAllBalance = originTransaction.extrinsicType === ExtrinsicType.TRANSFER_BALANCE && !!(originTransferData !== null && originTransferData !== void 0 && originTransferData.transferAll);
+    const maxTransferableWithoutFee = originTransferData === null || originTransferData === void 0 ? void 0 : originTransferData.maxTransferableWithoutFee;
+    const maxTransferable = originTransferData === null || originTransferData === void 0 ? void 0 : originTransferData.maxTransferable;
+    if (isTransferAllBalance && !!maxTransferableWithoutFee && !!maxTransferable) {
+      if (isSignerProxiedAccount) {
+        this.#koniState.transactionService.updateTransaction(transactionId, {
+          data: {
+            ...originTransferData,
+            value: maxTransferable,
+            transferNativeAmount: maxTransferable
+          }
+        });
+      } else {
+        this.#koniState.transactionService.updateTransaction(transactionId, {
+          data: {
+            ...originTransferData,
+            value: maxTransferableWithoutFee,
+            transferNativeAmount: maxTransferableWithoutFee
+          }
+        });
+      }
+
+      // Refresh originTransaction after update
+      originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
+    }
+
+    // If signer is the proxied account itself, the original transaction will be signed and sent directly without proxy execution.
+    if (isSignerProxiedAccount) {
+      const restData = Object.fromEntries(Object.entries(originTransaction.data || {}).filter(([key]) => key !== 'signer'));
+      this.#koniState.transactionService.updateTransaction(transactionId, {
+        data: restData
+      });
+    } else {
+      this.#koniState.transactionService.updateTransaction(transactionId, {
+        data: {
+          ...originTransaction.data,
+          signer
+        }
+      });
+    }
+    originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
+
     // Case 1: signer === proxied address → handle original transaction
     if (isSignerProxiedAccount) {
       let callDataFinal = callData;
@@ -3343,6 +3538,8 @@ export default class KoniExtension {
         decodedCallData,
         submittedCallData: substrateProxyExtrinsic.toHex(),
         callData,
+        signer,
+        signerAddress: signer,
         networkFee
       },
       wrappingStatus: SubstrateTransactionWrappingStatus.WRAP_RESULT,
@@ -3530,7 +3727,8 @@ export default class KoniExtension {
       request,
       resolve
     } = queued;
-    const pair = keyring.getPair(queued.address);
+    const signingAddress = queued.signerAddress || queued.address;
+    const pair = keyring.getPair(signingAddress);
 
     // unlike queued.account.address the following
     // address is encoded with the default prefix
@@ -3560,10 +3758,26 @@ export default class KoniExtension {
       }
     }
     const result = request.sign(registry, pair);
+    let signedTransaction;
+    if (queued.signerAddress && isJsonPayload(payload)) {
+      try {
+        const [chain] = this.#koniState.findNetworkKeyByGenesisHash(payload.genesisHash);
+        if (chain) {
+          const {
+            extrinsic
+          } = await this.buildExtrinsicFromPayload(chain, payload);
+          extrinsic.addSignature(payload.address, result.signature, payload);
+          signedTransaction = extrinsic.toHex();
+        }
+      } catch (e) {
+        console.error('Failed to build signed transaction for wrapped multisig signing', e);
+      }
+    }
     resolve({
       id,
       // In case evm chain, must be cut 2 character after 0x
-      signature: result.signature
+      signature: result.signature,
+      signedTransaction
     });
     if (this.#alwaysLock) {
       this.keyringLock();
@@ -4325,7 +4539,8 @@ export default class KoniExtension {
       errorOnTimeOut,
       ...this.createPassConfirmationParams(isPassConfirmation),
       eventsHandler,
-      step
+      step,
+      xcmFeeDryRun: extrinsicType === ExtrinsicType.TRANSFER_XCM ? submitData.xcmStepFee : undefined
     });
   }
   async handleYieldLeave(params) {
@@ -5627,6 +5842,8 @@ export default class KoniExtension {
         return await this.reconnectChain(request);
       case 'pri(chainService.disableChain)':
         return await this.disableChain(request);
+      case 'pri(chainService.disableAllChains)':
+        return await this.#koniState.disableAllChains();
       case 'pri(chainService.removeChain)':
         return this.removeCustomChain(request);
       case 'pri(chainService.validateCustomChain)':
@@ -6006,6 +6223,8 @@ export default class KoniExtension {
         return await this.cancelPendingTx(request);
       case 'pri(multisig.initMultisigTx)':
         return await this.initMultisigTx(request);
+      case 'pri(multisig.prepareSignRequest)':
+        return await this.prepareMultisigSignRequest(request);
       case 'pri(multisig.getSignableAccountInfos)':
         return this.#koniState.keyringService.context.getSignableAccountInfos(request);
       /* Multisig Account */

package/koni/background/handlers/State.d.ts

@@ -196,6 +196,7 @@ export default class KoniState {
     forceRemoveChain(networkKey: string): void;
     private getDefaultNetworkKeys;
     disableChain(chainSlug: string): Promise<boolean>;
+    disableAllChains(): Promise<boolean>;
     enableChain(chainSlug: string, enableTokens?: boolean): Promise<boolean>;
     enableChainWithPriorityAssets(chainSlug: string, enableTokens?: boolean): Promise<boolean>;
     resetDefaultChains(): boolean;

package/koni/background/handlers/State.js

@@ -749,6 +749,26 @@ export default class KoniState {
     }
     return this.chainService.disableChain(chainSlug);
   }
+  async disableAllChains() {
+    const chainStateMap = this.chainService.getChainStateMap();
+    const activeChainSlugs = Object.keys(chainStateMap).filter(slug => chainStateMap[slug].active);
+    const failedChainSlugs = [];
+    for (const chainSlug of activeChainSlugs) {
+      try {
+        const isDisabled = await this.disableChain(chainSlug);
+        if (!isDisabled) {
+          failedChainSlugs.push(chainSlug);
+        }
+      } catch (error) {
+        failedChainSlugs.push(chainSlug);
+        this.logger.error(`Failed to disable chain ${chainSlug}`, error);
+      }
+    }
+    if (failedChainSlugs.length) {
+      throw new Error('Unable to turn off all networks. Please try again later');
+    }
+    return true;
+  }
   async enableChain(chainSlug, enableTokens = true) {
     if (enableTokens) {
       await this.chainService.updateAssetSettingByChain(chainSlug, true);

package/koni/background/handlers/Tabs.js

@@ -69,11 +69,10 @@ function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthTyp
   const injectedAccounts = Object.values(accounts).filter(({
     json: {
       meta: {
-        isHidden,
-        isMultisig
+        isHidden
       }
     }
-  }) => !isHidden && !isMultisig).filter(authTypeFilter).filter(({
+  }) => !isHidden).filter(authTypeFilter).filter(({
     json: {
       address
     }

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.76-0",
+  "version": "1.3.78-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -804,6 +804,21 @@
       "require": "./cjs/services/balance-service/transfer/xcm/availBridge.js",
       "default": "./services/balance-service/transfer/xcm/availBridge.js"
     },
+    "./services/balance-service/transfer/xcm/bittensorBridge": {
+      "types": "./services/balance-service/transfer/xcm/bittensorBridge/index.d.ts",
+      "require": "./cjs/services/balance-service/transfer/xcm/bittensorBridge/index.js",
+      "default": "./services/balance-service/transfer/xcm/bittensorBridge/index.js"
+    },
+    "./services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge": {
+      "types": "./services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge.d.ts",
+      "require": "./cjs/services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge.js",
+      "default": "./services/balance-service/transfer/xcm/bittensorBridge/nativeTokenBridge.js"
+    },
+    "./services/balance-service/transfer/xcm/bittensorBridge/utils": {
+      "types": "./services/balance-service/transfer/xcm/bittensorBridge/utils.d.ts",
+      "require": "./cjs/services/balance-service/transfer/xcm/bittensorBridge/utils.js",
+      "default": "./services/balance-service/transfer/xcm/bittensorBridge/utils.js"
+    },
     "./services/balance-service/transfer/xcm/polygonBridge": {
       "types": "./services/balance-service/transfer/xcm/polygonBridge.d.ts",
       "require": "./cjs/services/balance-service/transfer/xcm/polygonBridge.js",
@@ -2091,6 +2106,11 @@
       "require": "./cjs/services/swap-service/handler/base-handler.js",
       "default": "./services/swap-service/handler/base-handler.js"
     },
+    "./services/swap-service/handler/bittensor-handler": {
+      "types": "./services/swap-service/handler/bittensor-handler.d.ts",
+      "require": "./cjs/services/swap-service/handler/bittensor-handler.js",
+      "default": "./services/swap-service/handler/bittensor-handler.js"
+    },
     "./services/swap-service/handler/chainflip-handler": {
       "types": "./services/swap-service/handler/chainflip-handler.d.ts",
       "require": "./cjs/services/swap-service/handler/chainflip-handler.js",
@@ -3008,11 +3028,11 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
     "@subwallet-monorepos/subwallet-services-sdk": "0.1.16",
-    "@subwallet/chain-list": "0.2.125",
-    "@subwallet/extension-base": "^1.3.76-0",
-    "@subwallet/extension-chains": "^1.3.76-0",
-    "@subwallet/extension-dapp": "^1.3.76-0",
-    "@subwallet/extension-inject": "^1.3.76-0",
+    "@subwallet/chain-list": "0.2.127",
+    "@subwallet/extension-base": "^1.3.78-0",
+    "@subwallet/extension-chains": "^1.3.78-0",
+    "@subwallet/extension-dapp": "^1.3.78-0",
+    "@subwallet/extension-inject": "^1.3.78-0",
     "@subwallet/keyring": "^0.1.14",
     "@subwallet/ui-keyring": "^0.1.14",
     "@ton/core": "^0.56.3",

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.76-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];