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

package/services/chain-service/index.js

@@ -1018,6 +1018,9 @@ export class ChainService {
   async fetchLatestSufficientChains() {
     return (await fetchStaticData('chains/supported-sufficient-chains')) || [];
   }
+  async fetchAhMapChain() {
+    return await fetchStaticData('asset-hub-staking-map');
+  }
   async initChains() {
     const storedChainSettings = await this.dbService.getAllChainStore();
     const defaultChainInfoMap = filterChainInfoMap(ChainInfoMap, ignoredList);

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

@@ -2,7 +2,7 @@ import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from
 import { BasicTokenInfo } from '@subwallet/extension-base/background/KoniTypes';
 import { _ChainState, _DataMap } from '@subwallet/extension-base/services/chain-service/types';
 import { IChain } from '@subwallet/extension-base/services/storage-service/databases';
-import { AccountChainType } from '@subwallet/extension-base/types';
+import { AccountChainType, AccountSignMode } from '@subwallet/extension-base/types';
 import { KeypairType } from '@subwallet/keyring/types';
 export declare function _isCustomChain(slug: string): boolean;
 export declare function _isCustomAsset(slug: string): boolean;
@@ -40,6 +40,8 @@ export declare function _getTokenOnChainInfo(tokenInfo: _ChainAsset): Record<str
 export declare function _isBridgedToken(tokenInfo: _ChainAsset): boolean;
 export declare function _getTokenMinAmount(tokenInfo: _ChainAsset): string;
 export declare function _isChainEvmCompatible(chainInfo: _ChainInfo): boolean;
+export declare function _isChainCompatibleLedgerEvm(chainInfo: _ChainInfo): boolean;
+export declare function _isSubstrateEvmCompatibleChain(chainInfo: _ChainInfo): boolean;
 export declare function _isChainBitcoinCompatible(chainInfo: _ChainInfo): boolean;
 export declare function _isChainTonCompatible(chainInfo: _ChainInfo): boolean;
 export declare function _isChainCardanoCompatible(chainInfo: _ChainInfo): boolean;
@@ -68,6 +70,7 @@ export declare function _getNftTypesSupportedByChain(chainInfo: _ChainInfo): _As
 export declare function _getTokenTypesSupportedByChain(chainInfo: _ChainInfo): _AssetType[];
 export declare function _getChainNativeTokenBasicInfo(chainInfo: _ChainInfo): BasicTokenInfo;
 export declare function _getChainNativeTokenSlug(chainInfo: _ChainInfo): string;
+export declare function _getChainSubstrateTokenSymbol(chainInfo: _ChainInfo): string;
 export declare function _isLocalToken(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenEvmSmartContract(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenTonSmartContract(tokenInfo: _ChainAsset): boolean;
@@ -119,6 +122,11 @@ export declare function updateLatestChainInfo(currentDataMap: _DataMap, latestCh
     needUpdateChainApiList: _ChainInfo[];
 };
 export declare const _chainInfoToChainType: (chainInfo: _ChainInfo) => AccountChainType;
-export declare const _isChainInfoCompatibleWithAccountInfo: (chainInfo: _ChainInfo, accountChainType: AccountChainType, accountType: KeypairType) => boolean;
+interface AccountInfo {
+    chainType: AccountChainType;
+    type: KeypairType;
+    signMode?: AccountSignMode;
+}
+export declare const _isChainInfoCompatibleWithAccountInfo: (chainInfo: _ChainInfo, accountInfo: AccountInfo) => boolean;
 export declare const _getAssetNetuid: (assetInfo: _ChainAsset) => number;
 export * from './patch';

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

@@ -4,7 +4,7 @@
 import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
 import { _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _CUSTOM_PREFIX, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { AccountChainType } from '@subwallet/extension-base/types';
+import { AccountChainType, AccountSignMode } from '@subwallet/extension-base/types';
 import { BitcoinMainnetKeypairTypes, BitcoinTestnetKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 export function _isCustomChain(slug) {
@@ -142,6 +142,12 @@ export function _getTokenMinAmount(tokenInfo) {
 export function _isChainEvmCompatible(chainInfo) {
   return !!chainInfo.evmInfo;
 }
+export function _isChainCompatibleLedgerEvm(chainInfo) {
+  return !!chainInfo.evmInfo && chainInfo.evmInfo.evmChainId > 0;
+}
+export function _isSubstrateEvmCompatibleChain(chainInfo) {
+  return !!chainInfo.evmInfo && !!chainInfo.substrateInfo;
+}
 export function _isChainBitcoinCompatible(chainInfo) {
   return !!chainInfo.bitcoinInfo;
 }
@@ -312,6 +318,13 @@ export function _getChainNativeTokenSlug(chainInfo) {
   }
   return `${chainInfo.slug}-${_AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
 }
+export function _getChainSubstrateTokenSymbol(chainInfo) {
+  if (chainInfo.substrateInfo) {
+    return chainInfo.substrateInfo.symbol || '';
+  } else {
+    return '';
+  }
+}
 export function _isLocalToken(tokenInfo) {
   return tokenInfo.assetType === _AssetType.LOCAL;
 }
@@ -594,11 +607,22 @@ export const _chainInfoToChainType = chainInfo => {
   }
   return AccountChainType.SUBSTRATE;
 };
-export const _isChainInfoCompatibleWithAccountInfo = (chainInfo, accountChainType, accountType) => {
+export const _isChainInfoCompatibleWithAccountInfo = (chainInfo, accountInfo) => {
+  const {
+    chainType: accountChainType,
+    signMode: accountSignMode,
+    type: accountType
+  } = accountInfo;
   if (accountChainType === AccountChainType.SUBSTRATE) {
     return _isPureSubstrateChain(chainInfo) && SubstrateKeypairTypes.includes(accountType);
   }
   if (accountChainType === AccountChainType.ETHEREUM) {
+    if (accountSignMode === AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
+      return _isSubstrateEvmCompatibleChain(chainInfo) && EthereumKeypairTypes.includes(accountType);
+    }
+    if (accountSignMode === AccountSignMode.GENERIC_LEDGER) {
+      return _isChainCompatibleLedgerEvm(chainInfo) && EthereumKeypairTypes.includes(accountType);
+    }
     return _isChainEvmCompatible(chainInfo) && EthereumKeypairTypes.includes(accountType);
   }
   if (accountChainType === AccountChainType.TON) {

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

@@ -1,5 +1,6 @@
 export declare const _STAKING_CHAIN_GROUP: {
     relay: string[];
+    assetHub: string[];
     para: string[];
     astar: string[];
     amplitude: string[];

package/services/earning-service/constants/chains.js

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export const _STAKING_CHAIN_GROUP = {
-  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet', 'availTuringTest', 'avail_mainnet', 'vara_testnet', 'dentnet', 'cere'],
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet', 'availTuringTest', 'avail_mainnet', 'vara_testnet', 'dentnet', 'cere', 'statemine', 'statemint', 'westend_assethub'],
+  assetHub: ['statemine', 'statemint', 'westend_assethub'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network', 'polimec'],
   astar: ['astar', 'shiden', 'shibuya'],
   amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],

package/services/earning-service/handlers/native-staking/base.d.ts

@@ -8,6 +8,7 @@ export default abstract class BaseNativeStakingPoolHandler extends BasePoolHandl
     protected readonly shortName: string;
     slug: string;
     protected readonly availableMethod: YieldPoolMethodInfo;
+    static generateSlug(symbol: string, chain: string): string;
     constructor(state: KoniState, chain: string);
     protected getDescription(amount?: string): string;
     getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;

package/services/earning-service/handlers/native-staking/base.js

@@ -16,6 +16,9 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
     withdraw: true,
     claimReward: false
   };
+  static generateSlug(symbol, chain) {
+    return `${symbol}___native_staking___${chain}`;
+  }
   constructor(state, chain) {
     super(state, chain);
     const _chainAsset = this.nativeToken;

package/services/earning-service/handlers/native-staking/relay-chain.js

@@ -651,8 +651,15 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
   async handleYieldWithdraw(address, unstakingInfo) {
     const chainApi = await this.substrateApi.isReady;
     if (chainApi.api.tx.staking.withdrawUnbonded.meta.args.length === 1) {
-      const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(address)).toHuman();
-      const slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+      let slashingSpanCount;
+      if (chainApi.api.query.staking.nominatorSlashInEra) {
+        const currentEra = await chainApi.api.query.staking.currentEra();
+        const slashingSpans = (await chainApi.api.query.staking.nominatorSlashInEra(currentEra.toPrimitive(), address)).toPrimitive();
+        slashingSpanCount = slashingSpans !== null ? slashingSpans.toString() : '0';
+      } else {
+        const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(address)).toHuman();
+        slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+      }
       return chainApi.api.tx.staking.withdrawUnbonded(slashingSpanCount);
     } else {
       // @ts-ignore

package/services/earning-service/handlers/nomination-pool/index.d.ts

@@ -12,6 +12,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
     protected readonly shortName: string;
     slug: string;
     protected readonly availableMethod: YieldPoolMethodInfo;
+    static generateSlug(symbol: string, chain: string): string;
     constructor(state: KoniState, chain: string);
     protected getDescription(amount?: string): string;
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;

package/services/earning-service/handlers/nomination-pool/index.js

@@ -22,6 +22,9 @@ export default class NominationPoolHandler extends BasePoolHandler {
     withdraw: true,
     claimReward: true
   };
+  static generateSlug(symbol, chain) {
+    return `${symbol}___nomination_pool___${chain}`;
+  }
   constructor(state, chain) {
     super(state, chain);
     const _chainAsset = this.nativeToken;
@@ -79,7 +82,8 @@ export default class NominationPoolHandler extends BasePoolHandler {
       const maxUnlockingChunks = substrateApi.api.consts.staking.maxUnlockingChunks.toString();
       const unlockingEras = substrateApi.api.consts.staking.bondingDuration.toString();
       const maxSupportedEras = substrateApi.api.consts.staking.historyDepth.toString();
-      const erasPerDay = 24 / _STAKING_ERA_LENGTH_MAP[chainInfo.slug]; // Can be exactly calculate from epochDuration, blockTime, sessionsPerEra
+      const eraInHours = _STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _STAKING_ERA_LENGTH_MAP.default; // in hours
+      const erasPerDay = 24 / eraInHours; // Can be exactly calculate from epochDuration, blockTime, sessionsPerEra
 
       const supportedDays = getSupportedDaysByHistoryDepth(erasPerDay, parseInt(maxSupportedEras), parseInt(currentEra) / erasPerDay);
       const startEra = parseInt(currentEra) - supportedDays * erasPerDay;
@@ -560,8 +564,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
   async handleYieldWithdraw(address, unstakingInfo) {
     const chainApi = await this.substrateApi.isReady;
     if (chainApi.api.tx.nominationPools.withdrawUnbonded.meta.args.length === 2) {
-      const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(address)).toHuman();
-      const slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+      const slashingSpanCount = await chainApi.api.call.nominationPoolsApi.memberPendingSlash(address);
       return chainApi.api.tx.nominationPools.withdrawUnbonded({
         Id: address
       }, slashingSpanCount);

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

@@ -12,6 +12,7 @@ export default class EarningService implements StoppableServiceInterface, Persis
     protected readonly state: KoniState;
     protected handlers: Record<string, BasePoolHandler>;
     private handlerCache;
+    private inactivePoolSlug;
     private earningRewardSubject;
     private earningRewardHistorySubject;
     private minAmountPercentSubject;
@@ -21,6 +22,7 @@ export default class EarningService implements StoppableServiceInterface, Persis
     private dbService;
     private eventService;
     private useOnlineCacheOnly;
+    private inactivePoolReady;
     constructor(state: KoniState);
     disableOnlineCacheOnly(): void;
     private initHandlers;

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();

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/types/account/action/subscribe.d.ts

@@ -1,6 +1,9 @@
+import { ActionType } from '@subwallet/extension-base/core/types';
 export interface RequestInputAccountSubscribe {
     data: string;
     chain: string;
+    token?: string;
+    actionType?: ActionType;
 }
 export declare enum AnalyzedGroup {
     WALLET = "wallet",

package/types/account/info/keyring.d.ts

@@ -54,6 +54,8 @@ export interface AccountLedgerData {
     availableGenesisHashes?: string[];
     /** Is Ledger recovery chain */
     isLedgerRecovery?: boolean;
+    /** Is Ledger substrate ECDSA scheme signature */
+    isSubstrateECDSA?: boolean;
 }
 /**
  * @interface AccountInjectData
@@ -103,6 +105,7 @@ export declare enum AccountSignMode {
     QR = "qr",
     LEGACY_LEDGER = "legacy-ledger",
     GENERIC_LEDGER = "generic-ledger",
+    ECDSA_SUBSTRATE_LEDGER = "ecdsa-substrate-ledger",
     READ_ONLY = "readonly",
     ALL_ACCOUNT = "all",
     INJECTED = "injected",

package/types/account/info/keyring.js

@@ -54,6 +54,7 @@ export let AccountSignMode;
   AccountSignMode["QR"] = "qr";
   AccountSignMode["LEGACY_LEDGER"] = "legacy-ledger";
   AccountSignMode["GENERIC_LEDGER"] = "generic-ledger";
+  AccountSignMode["ECDSA_SUBSTRATE_LEDGER"] = "ecdsa-substrate-ledger";
   AccountSignMode["READ_ONLY"] = "readonly";
   AccountSignMode["ALL_ACCOUNT"] = "all";
   AccountSignMode["INJECTED"] = "injected";

package/types/balance/transfer.d.ts

@@ -31,6 +31,7 @@ export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     transferAll: boolean;
     value: string;
     transferBounceable?: boolean;
+    isSubstrateECDSATransaction?: boolean;
 }
 export interface RequestSubmitSignPsbtTransfer extends BaseRequestSign {
     id: string;

package/utils/account/analyze.js

@@ -58,7 +58,7 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
   for (const accountProxy of accountProxies) {
     const _name = accountProxy.name.trim().toLowerCase();
     const nameCondition = isNameValid(_data, _name);
-    const filterAccounts = accountProxy.accounts.filter(account => _isChainInfoCompatibleWithAccountInfo(chainInfo, account.chainType, account.type));
+    const filterAccounts = accountProxy.accounts.filter(account => _isChainInfoCompatibleWithAccountInfo(chainInfo, account));
     for (const account of filterAccounts) {
       const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
       const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
@@ -86,7 +86,10 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
       }
     }
   }
-  const filterContacts = contacts.filter(contact => _isChainInfoCompatibleWithAccountInfo(chainInfo, contact.chainType, getKeypairTypeByAddress(contact.address)));
+  const filterContacts = contacts.filter(contact => _isChainInfoCompatibleWithAccountInfo(chainInfo, {
+    chainType: contact.chainType,
+    type: getKeypairTypeByAddress(contact.address)
+  }));
 
   // Filter address book addresses
   for (const contact of filterContacts) {