@subwallet/extension-base 1.3.45-1 → 1.3.47-0

package/services/earning-service/service.js

@@ -2,15 +2,15 @@
 // 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 { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
-import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainSubstrateTokenSymbol, _isChainEnabled } from '@subwallet/extension-base/services/chain-service/utils';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
 import BaseLiquidStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base';
 import MythosNativeStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/mythos';
 import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
-import { addLazy, createPromiseHandler, getAddressesByChainType, removeLazy } from '@subwallet/extension-base/utils';
+import { addLazy, createPromiseHandler, filterAddressByChainInfo, removeLazy } from '@subwallet/extension-base/utils';
 import { fetchStaticCache } from '@subwallet/extension-base/utils/fetchStaticCache';
 import { BehaviorSubject } from 'rxjs';
 import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, BifrostMantaLiquidStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler, SubnetTaoStakingPoolHandler, TaoNativeStakingPoolHandler } from "./handlers/index.js";
@@ -23,6 +23,7 @@ const fetchPoolsData = async () => {
 export default class EarningService {
   handlers = {};
   handlerCache = new Map();
+  inactivePoolSlug = new Set();
   earningRewardSubject = new BehaviorSubject({
     ready: false,
     data: {}
@@ -36,6 +37,7 @@ export default class EarningService {
   yieldPositionListSubject = new BehaviorSubject([]); // virtual list of yieldPositionSubject with filter values
 
   useOnlineCacheOnly = true;
+  inactivePoolReady = createPromiseHandler();
   constructor(state) {
     this.state = state;
     this.dbService = state.dbService;
@@ -53,10 +55,23 @@ export default class EarningService {
       }
     }
     const minAmountPercent = {};
+    const ahMapChain = await this.state.chainService.fetchAhMapChain();
     for (const chain of chains) {
       const handlers = [];
+      const chainInfo = this.state.getChainInfo(chain);
+      const symbol = _getChainSubstrateTokenSymbol(chainInfo);
       if (_STAKING_CHAIN_GROUP.relay.includes(chain)) {
-        handlers.push(new RelayNativeStakingPoolHandler(this.state, chain));
+        if (_STAKING_CHAIN_GROUP.assetHub.includes(chain)) {
+          continue;
+        }
+        const ahChain = ahMapChain[chain];
+        if (ahChain) {
+          handlers.push(new RelayNativeStakingPoolHandler(this.state, ahChain));
+          const relaySlug = RelayNativeStakingPoolHandler.generateSlug(symbol, chain);
+          this.inactivePoolSlug.add(relaySlug);
+        } else {
+          handlers.push(new RelayNativeStakingPoolHandler(this.state, chain));
+        }
       }
       if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
         handlers.push(new ParaNativeStakingPoolHandler(this.state, chain));
@@ -77,7 +92,14 @@ export default class EarningService {
         handlers.push(new MythosNativeStakingPoolHandler(this.state, chain));
       }
       if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
-        handlers.push(new NominationPoolHandler(this.state, chain));
+        const ahChain = ahMapChain[chain];
+        if (ahChain) {
+          handlers.push(new NominationPoolHandler(this.state, ahChain));
+          const relaySlug = NominationPoolHandler.generateSlug(symbol, chain);
+          this.inactivePoolSlug.add(relaySlug);
+        } else {
+          handlers.push(new NominationPoolHandler(this.state, chain));
+        }
       }
       if (_STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
         if (chain === 'bifrost_dot') {
@@ -110,6 +132,7 @@ export default class EarningService {
     }
     minAmountPercent.default = BaseLiquidStakingPoolHandler.defaultMinAmountPercent;
     this.minAmountPercentSubject.next(minAmountPercent);
+    this.inactivePoolReady.resolve();
 
     // Emit earning ready
     this.eventService.emit('earning.ready', true);
@@ -129,7 +152,7 @@ export default class EarningService {
       next: data => {
         const activeMap = this.state.getActiveChainInfoMap();
         const activePositions = Object.values(data).filter(item => {
-          return !!activeMap[item.chain];
+          return !!activeMap[item.chain] && !this.inactivePoolSlug.has(item.slug);
         });
         this.yieldPositionListSubject.next(Object.values(activePositions));
       }
@@ -312,7 +335,9 @@ export default class EarningService {
     const yieldPoolInfo = {};
     const existedYieldPoolInfo = await this.dbService.getYieldPools();
     existedYieldPoolInfo.forEach(info => {
-      yieldPoolInfo[info.slug] = info;
+      if (!this.inactivePoolSlug.has(info.slug)) {
+        yieldPoolInfo[info.slug] = info;
+      }
     });
     this.yieldPoolInfoSubject.next(yieldPoolInfo);
   }
@@ -347,6 +372,10 @@ export default class EarningService {
   }
   async fetchingPoolsInfoOnline() {
     const onlineData = await fetchPoolsData();
+    await this.inactivePoolReady.promise;
+    for (const inactiveSlug of this.inactivePoolSlug) {
+      delete onlineData[inactiveSlug];
+    }
     Object.values(onlineData).forEach(item => {
       this.updateYieldPoolInfo(item);
     });
@@ -389,14 +418,11 @@ export default class EarningService {
   async subscribePoolPositions(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
-    const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
       if (activeChains.includes(handler.chain)) {
-        const chainInfo = handler.chainInfo;
-        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        const [useAddresses] = filterAddressByChainInfo(addresses, handler.chainInfo);
         handler.subscribePoolPosition(useAddresses, callback).then(unsub => {
           if (cancel) {
             unsub();
@@ -442,7 +468,9 @@ export default class EarningService {
     const existedYieldPosition = await this.dbService.getYieldNominationPoolPosition(addresses, this.state.activeChainSlugs);
     const yieldPositionInfo = this.yieldPositionSubject.getValue();
     existedYieldPosition.forEach(item => {
-      yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = item;
+      if (!this.inactivePoolSlug.has(item.slug)) {
+        yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = item;
+      }
     });
     this.yieldPositionSubject.next(yieldPositionInfo);
   }
@@ -533,14 +561,11 @@ export default class EarningService {
   async getPoolReward(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
-    const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
       if (activeChains.includes(handler.chain)) {
-        const chainInfo = handler.chainInfo;
-        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        const [useAddresses] = filterAddressByChainInfo(addresses, handler.chainInfo);
         handler.getPoolReward(useAddresses, callback).then(unsub => {
           if (cancel) {
             unsub();
@@ -589,14 +614,11 @@ export default class EarningService {
   async fetchPoolRewardHistory(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
-    const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
       if (activeChains.includes(handler.chain)) {
-        const chainInfo = handler.chainInfo;
-        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        const [useAddresses] = filterAddressByChainInfo(addresses, handler.chainInfo);
         handler.getPoolRewardHistory(useAddresses, callback).then(unsub => {
           if (cancel) {
             unsub();
@@ -638,18 +660,39 @@ export default class EarningService {
     if (!addresses.length) {
       return;
     }
-    this.fetchPoolRewardHistory(addresses, result => {
-      this.updateEarningRewardHistory(result);
-    }).catch(console.error);
-    this.earningsRewardHistoryInterval = setInterval(() => {
+    let cancel = false;
+    let unsub;
+    this.unSubFetchEarningRewardHistory = () => {
+      if (!cancel) {
+        var _unsub2;
+        (_unsub2 = unsub) === null || _unsub2 === void 0 ? void 0 : _unsub2();
+        cancel = true;
+      }
+    };
+    const fetchData = () => {
       this.fetchPoolRewardHistory(addresses, result => {
+        if (cancel) {
+          return;
+        }
         this.updateEarningRewardHistory(result);
+      }).then(_unsub => {
+        if (!cancel) {
+          var _unsub3;
+          (_unsub3 = unsub) === null || _unsub3 === void 0 ? void 0 : _unsub3();
+          unsub = _unsub;
+        }
       }).catch(console.error);
-    }, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL);
+    };
+    if (!cancel) {
+      fetchData();
+    }
+    this.earningsRewardHistoryInterval = setInterval(fetchData, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL);
   }
   runUnsubscribeEarningRewardHistoryInterval() {
+    var _this$unSubFetchEarni;
     removeLazy('updateEarningRewardHistory');
     this.earningRewardHistoryQueue = [];
+    (_this$unSubFetchEarni = this.unSubFetchEarningRewardHistory) === null || _this$unSubFetchEarni === void 0 ? void 0 : _this$unSubFetchEarni.call(this);
     this.earningsRewardHistoryInterval && clearInterval(this.earningsRewardHistoryInterval);
   }
 

package/services/history-service/index.js

@@ -74,7 +74,7 @@ export class HistoryService {
   /**
    * @todo: Must improve performance of this function
    * */
-  fetchSubscanTransactionHistory(chain, addresses) {
+  fetchSubscanTransactionHistory(chain, addresses, groupId) {
     if (!this.subscanService.checkSupportedSubscanChain(chain) || !addresses.length) {
       return;
     }
@@ -87,7 +87,7 @@ export class HistoryService {
     // However, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
     // to avoid "duplicate Extrinsic Hash between items" problem
 
-    this.subscanService.fetchAllPossibleExtrinsicItems(chain, address, extrinsicItems => {
+    this.subscanService.fetchAllPossibleExtrinsicItems(groupId, chain, address, extrinsicItems => {
       const result = [];
       extrinsicItems.forEach(x => {
         const item = parseSubscanExtrinsicData(address, x, chainInfo);
@@ -105,7 +105,7 @@ export class HistoryService {
           excludeTransferExtrinsicHash.push(x.extrinsic_hash);
         }
       });
-      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent').then(rsMap => {
+      this.subscanService.fetchAllPossibleTransferItems(groupId, chain, address, 'sent').then(rsMap => {
         const result = [];
         Object.keys(rsMap).forEach(hash => {
           // only push item that does not have same hash with another item
@@ -125,7 +125,7 @@ export class HistoryService {
     }).catch(e => {
       console.log('fetchAllPossibleExtrinsicItems error', e);
     });
-    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received').then(rsMap => {
+    this.subscanService.fetchAllPossibleTransferItems(groupId, chain, address, 'received').then(rsMap => {
       const result = [];
       Object.keys(rsMap).forEach(hash => {
         // only push item that does not have same hash with another item
@@ -172,14 +172,19 @@ export class HistoryService {
     const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
     const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
     const bitcoinAddresses = getAddressesByChainType(addresses, [ChainType.BITCOIN], chainInfo);
+    const groupId = this.subscanService.getGroupId();
     const subscription = this.historySubject.subscribe(items => {
       cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
+    const unsubscribe = () => {
+      subscription.unsubscribe();
+      this.subscanService.cancelGroupRequest(groupId);
+    };
     if (_isChainSubstrateCompatible(chainInfo)) {
       if (_isChainEvmCompatible(chainInfo)) {
-        this.fetchSubscanTransactionHistory(chain, evmAddresses);
+        this.fetchSubscanTransactionHistory(chain, evmAddresses, groupId);
       } else {
-        this.fetchSubscanTransactionHistory(chain, substrateAddresses);
+        this.fetchSubscanTransactionHistory(chain, substrateAddresses, groupId);
       }
     } else if (_isChainBitcoinCompatible(chainInfo)) {
       this.fetchBitcoinTransactionHistory(chain, bitcoinAddresses).catch(e => {
@@ -187,7 +192,7 @@ export class HistoryService {
       });
     }
     return {
-      unsubscribe: subscription.unsubscribe,
+      unsubscribe,
       value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, addresses))
     };
   }

package/services/keyring-service/context/handlers/Json.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { AccountProxyType } from '@subwallet/extension-base/types';
 import { combineAccountsWithKeyPair, convertAccountProxyType, createPromiseHandler, transformAccount } from '@subwallet/extension-base/utils';
 import { generateRandomString } from '@subwallet/extension-base/utils/getId';
 import { createPair } from '@subwallet/keyring';
@@ -307,7 +308,7 @@ export class AccountJsonHandler extends AccountBaseHandler {
       const _proxyIds = proxyIds || Object.keys(_account);
       const modifyPairs = Object.fromEntries(Object.entries(_modifyPair).filter(([, modifyPair]) => _proxyIds.includes(modifyPair.accountProxyId || '')));
       const accountProxies = Object.fromEntries(Object.entries(_accountProxy).filter(([, proxy]) => _proxyIds.includes(proxy.id)));
-      const addresses = Object.values(_account).filter(account => _proxyIds.includes(account.id)).flatMap(proxy => proxy.accounts.map(account => account.address));
+      const addresses = Object.values(_account).filter(account => _proxyIds.includes(account.id) && account.accountType !== AccountProxyType.LEDGER).flatMap(proxy => proxy.accounts.map(account => account.address));
       const rs = await keyring.backupAccounts(password, addresses);
       if (Object.keys(modifyPairs).length && Object.keys(accountProxies).length) {
         rs.accountProxies = accountProxies;

package/services/keyring-service/context/handlers/Ledger.js

@@ -95,6 +95,7 @@ export class AccountLedgerHandler extends AccountBaseHandler {
         isEthereum,
         isGeneric,
         isLedgerRecovery,
+        isSubstrateECDSA,
         name,
         originGenesisHash
       } = account;
@@ -106,9 +107,13 @@ export class AccountLedgerHandler extends AccountBaseHandler {
         genesisHash,
         originGenesisHash,
         isGeneric,
-        isLedgerRecovery
+        isLedgerRecovery,
+        isSubstrateECDSA
       };
-      const type = isEthereum ? 'ethereum' : 'sr25519';
+      let type = 'sr25519';
+      if (isEthereum || isSubstrateECDSA) {
+        type = 'ethereum';
+      }
       const pair = keyring.keyring.createFromAddress(address, {
         ...baseMeta,
         isExternal: true,

package/services/request-service/handler/AuthRequestHandler.d.ts

@@ -18,6 +18,7 @@ export default class AuthRequestHandler {
     private init;
     private migrateAuthUrlInfoToUnified;
     private getAddressList;
+    private getEcdsaAddressList;
     get numAuthRequestsV2(): number;
     private get allAuthRequestsV2();
     private updateIconAuthV2;

package/services/request-service/handler/AuthRequestHandler.js

@@ -47,6 +47,9 @@ export default class AuthRequestHandler {
       } else if (!value.currentNetworkMap) {
         value.currentNetworkMap = {};
       }
+      if (existKeyBothConnectAuthType) {
+        value.canConnectSubstrateEcdsa = true;
+      }
       acc[key] = {
         ...value
       };
@@ -81,6 +84,18 @@ export default class AuthRequestHandler {
       [v]: value
     }), {});
   }
+  getEcdsaAddressList() {
+    const addressList = Object.keys(this.keyringService.context.pairs);
+    const pairs = this.keyringService.context.pairs;
+    const ecdsaAddressList = new Set();
+    addressList.forEach(address => {
+      const pair = pairs[address];
+      if (pair && pair.json.meta.isSubstrateECDSA) {
+        ecdsaAddressList.add(address);
+      }
+    });
+    return ecdsaAddressList;
+  }
   get numAuthRequestsV2() {
     return Object.keys(this.#authRequestsV2).length;
   }
@@ -188,6 +203,7 @@ export default class AuthRequestHandler {
   }
   authCompleteV2 = (id, url, resolve, reject) => {
     const isAllowedMap = this.getAddressList();
+    const ecdsaAddressList = this.getEcdsaAddressList();
     const complete = (result, cb, accounts) => {
       const isAllowed = result === true;
       let isCancelled = false;
@@ -208,6 +224,7 @@ export default class AuthRequestHandler {
         idStr,
         request: {
           allowedAccounts,
+          canConnectSubstrateEcdsa,
           origin
         },
         url
@@ -215,10 +232,9 @@ export default class AuthRequestHandler {
 
       // Note: accountAuthTypes represents the accountAuthType of this request
       //       allowedAccounts is a list of connected accounts that exist for this origin during this request.
-
       if (accountAuthTypes.length !== ALL_ACCOUNT_AUTH_TYPES.length) {
         const backupAllowed = (allowedAccounts || []).filter(a => {
-          if (isEthereumAddress(a) && !accountAuthTypes.includes('evm')) {
+          if (isEthereumAddress(a) && (canConnectSubstrateEcdsa || !ecdsaAddressList.has(a)) && !accountAuthTypes.includes('evm')) {
             return true;
           }
           if (isSubstrateAddress(a) && !accountAuthTypes.includes('substrate')) {
@@ -281,7 +297,8 @@ export default class AuthRequestHandler {
           currentNetworkMap: existed ? {
             ...defaultNetworkMap,
             ...existed.currentNetworkMap
-          } : defaultNetworkMap
+          } : defaultNetworkMap,
+          canConnectSubstrateEcdsa: canConnectSubstrateEcdsa || (existed === null || existed === void 0 ? void 0 : existed.canConnectSubstrateEcdsa)
         };
         this.setAuthorize(authorizeList, () => {
           cb();
@@ -312,6 +329,7 @@ export default class AuthRequestHandler {
     const idStr = stripUrl(url);
     const isAllowedDappConnectBothType = !!DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL.find(url_ => url.includes(url_));
     let accountAuthTypes = [...new Set(isAllowedDappConnectBothType ? ['evm', 'substrate'] : request.accountAuthTypes || ['substrate'])];
+    let canConnectSubstrateEcdsa = !!request.canConnectSubstrateEcdsa || isAllowedDappConnectBothType;
     if (!authList) {
       authList = {};
     }
@@ -344,6 +362,9 @@ export default class AuthRequestHandler {
         if (accountAuthTypes && _request.accountAuthTypes) {
           const filteredAccountAuthTypes = new Set([..._request.accountAuthTypes, ...accountAuthTypes]);
           accountAuthTypes = [...filteredAccountAuthTypes];
+          if (_request.request.canConnectSubstrateEcdsa) {
+            canConnectSubstrateEcdsa = true;
+          }
         }
         mergeKeys.push(key);
       }
@@ -372,9 +393,10 @@ export default class AuthRequestHandler {
       }
       request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(([address, allowed]) => allowed ? address : '').filter(item => item !== '');
       let allowedListByRequestType = [...request.allowedAccounts];
+      const ecdsaAddressList = this.getEcdsaAddressList();
       allowedListByRequestType = accountAuthTypes.reduce((list, accountAuthType) => {
         if (accountAuthType === 'evm') {
-          list.push(...allowedListByRequestType.filter(a => isEthereumAddress(a)));
+          list.push(...allowedListByRequestType.filter(a => isEthereumAddress(a) && (canConnectSubstrateEcdsa || !ecdsaAddressList.has(a))));
         } else if (accountAuthType === 'substrate') {
           list.push(...allowedListByRequestType.filter(a => isSubstrateAddress(a)));
         } else if (accountAuthType === 'ton') {
@@ -405,7 +427,8 @@ export default class AuthRequestHandler {
           origin,
           url,
           accountAuthTypes: ALL_ACCOUNT_AUTH_TYPES,
-          currentNetworkMap: {}
+          currentNetworkMap: {},
+          canConnectSubstrateEcdsa
         };
         this.setAuthorize(authList);
         return true;
@@ -417,7 +440,8 @@ export default class AuthRequestHandler {
       idStr,
       request: {
         ...request,
-        accountAuthTypes
+        accountAuthTypes,
+        canConnectSubstrateEcdsa
       },
       url,
       accountAuthTypes: accountAuthTypes || ['substrate']

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

@@ -21,6 +21,7 @@ export interface AuthUrlInfo {
     isAllowedMap: Record<string, boolean>;
     currentNetworkMap: Partial<Record<AccountAuthType, string>>;
     currentAccount?: string;
+    canConnectSubstrateEcdsa?: boolean;
 }
 export interface AuthUrlInfoNeedMigration extends Omit<AuthUrlInfo, 'accountAuthTypes'> {
     accountAuthType?: AccountAuthType | 'both';

package/services/subscan-service/index.d.ts

@@ -1,44 +1,30 @@
-import { CrowdloanContributionsResponse, ExtrinsicItem, ExtrinsicsListResponse, IMultiChainBalance, RequestBlockRange, RewardHistoryListResponse, SubscanRequest, TransferItem, TransfersListResponse } from '@subwallet/extension-base/services/subscan-service/types';
+import { CrowdloanContributionsResponse, ExtrinsicItem, ExtrinsicsListResponse, IMultiChainBalance, RequestBlockRange, RewardHistoryListResponse, TransferItem, TransfersListResponse } from '@subwallet/extension-base/services/subscan-service/types';
+import { ApiRequestContextProps } from '@subwallet/extension-base/strategy/api-request-strategy/types';
+import { BaseApiRequestStrategyV2 } from '@subwallet/extension-base/strategy/api-request-strategy-v2';
 import { SubscanEventBaseItemData, SubscanExtrinsicParam } from '@subwallet/extension-base/types';
-export declare class SubscanService {
+export declare class SubscanService extends BaseApiRequestStrategyV2 {
     private subscanChainMap;
-    private callRate;
-    private limitRate;
-    private intervalCheck;
-    private maxRetry;
-    private rollbackRateTime;
-    private timeoutRollbackRate;
-    private requestMap;
-    private nextId;
-    private isRunning;
-    private getId;
-    constructor(subscanChainMap: Record<string, string>, options?: {
-        limitRate?: number;
-        intervalCheck?: number;
-        maxRetry?: number;
-    });
-    private reduceLimitRate;
+    constructor(subscanChainMap: Record<string, string>, options?: Partial<ApiRequestContextProps>);
     private getApiUrl;
     private postRequest;
-    addRequest<T>(run: SubscanRequest<T>['run'], ordinal: number): Promise<T>;
-    private process;
+    isRateLimited(e: Error): boolean;
     checkSupportedSubscanChain(chain: string): boolean;
     setSubscanChainMap(subscanChainMap: Record<string, string>): void;
     getMultiChainBalance(address: string): Promise<IMultiChainBalance[]>;
     getCrowdloanContributions(relayChain: string, address: string, page?: number): Promise<CrowdloanContributionsResponse>;
-    getExtrinsicsList(chain: string, address: string, page?: number, blockRange?: RequestBlockRange): Promise<ExtrinsicsListResponse>;
-    fetchAllPossibleExtrinsicItems(chain: string, address: string, cbAfterEachRequest?: (items: ExtrinsicItem[]) => void, limit?: {
+    getExtrinsicsList(groupId: number, chain: string, address: string, page?: number, blockRange?: RequestBlockRange): Promise<ExtrinsicsListResponse>;
+    fetchAllPossibleExtrinsicItems(groupId: number, chain: string, address: string, cbAfterEachRequest?: (items: ExtrinsicItem[]) => void, limit?: {
         page: number;
         record: number;
     }): Promise<ExtrinsicItem[]>;
-    getTransfersList(chain: string, address: string, page?: number, direction?: 'sent' | 'received', blockRange?: RequestBlockRange): Promise<TransfersListResponse>;
-    fetchAllPossibleTransferItems(chain: string, address: string, direction?: 'sent' | 'received', cbAfterEachRequest?: (items: TransferItem[]) => void, limit?: {
+    getTransfersList(groupId: number, chain: string, address: string, page?: number, direction?: 'sent' | 'received', blockRange?: RequestBlockRange): Promise<TransfersListResponse>;
+    fetchAllPossibleTransferItems(groupId: number, chain: string, address: string, direction?: 'sent' | 'received', cbAfterEachRequest?: (items: TransferItem[]) => void, limit?: {
         page: number;
         record: number;
     }): Promise<Record<string, TransferItem[]>>;
-    getRewardHistoryList(chain: string, address: string, page?: number): Promise<RewardHistoryListResponse>;
-    getAccountRemarkEvents(chain: string, address: string): Promise<SubscanEventBaseItemData[]>;
-    getExtrinsicParams(chain: string, extrinsicIndexes: string[], ordinal?: number): Promise<SubscanExtrinsicParam[]>;
+    getRewardHistoryList(groupId: number, chain: string, address: string, page?: number): Promise<RewardHistoryListResponse>;
+    getAccountRemarkEvents(groupId: number, chain: string, address: string): Promise<SubscanEventBaseItemData[]>;
+    getExtrinsicParams(groupId: number, chain: string, extrinsicIndexes: string[], ordinal?: number): Promise<SubscanExtrinsicParam[]>;
     private static _instance;
     static getInstance(): SubscanService;
 }