@subwallet/extension-base 1.3.22-0 → 1.3.24-0

package/services/history-service/index.js

@@ -1,14 +1,14 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { ExtrinsicStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainType, ExtrinsicStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_RECOVER_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEvmCompatible, _isChainSubstrateCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { historyRecover, HistoryRecoverStatus } from '@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus';
 import { getExtrinsicParserKey } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
 import { parseSubscanExtrinsicData, parseSubscanTransferData } from '@subwallet/extension-base/services/history-service/subscan-history';
-import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { getAddressesByChainType } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
@@ -144,19 +144,17 @@ export class HistoryService {
   }
   subscribeHistories(chain, proxyId, cb) {
     const addresses = this.keyringService.context.getDecodedAddresses(proxyId, false);
-    const {
-      evm,
-      substrate
-    } = categoryAddresses(addresses);
+    const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
+    const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
     const subscription = this.historySubject.subscribe(items => {
       cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
     const chainInfo = this.chainService.getChainInfoByKey(chain);
     if (_isChainSubstrateCompatible(chainInfo)) {
       if (_isChainEvmCompatible(chainInfo)) {
-        this.fetchSubscanTransactionHistory(chain, evm);
+        this.fetchSubscanTransactionHistory(chain, evmAddresses);
       } else {
-        this.fetchSubscanTransactionHistory(chain, substrate);
+        this.fetchSubscanTransactionHistory(chain, substrateAddresses);
       }
     }
     return {

package/services/inapp-notification-service/index.d.ts

@@ -28,10 +28,8 @@ export declare class InappNotificationService implements CronServiceInterface {
     validateAndWriteNotificationsToDB(notifications: _BaseNotificationInfo[], address: string): Promise<void>;
     cronCreateBridgeClaimNotification(): void;
     getCategorizedAddresses(): {
-        substrate: string[];
-        evm: string[];
-        ton: string[];
-        bitcoin: string[];
+        evmAddresses: string[];
+        substrateAddresses: string[];
     };
     createAvailBridgeClaimNotification(): void;
     processWriteAvailBridgeClaim(address: string, transactions: AvailBridgeTransaction[], token: _ChainAsset): Promise<void>;
@@ -44,4 +42,5 @@ export declare class InappNotificationService implements CronServiceInterface {
     stopCron(): Promise<void>;
     onAccountProxyRemove(): void;
     removeAccountNotifications(proxyId: string): void;
+    migrateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;
 }

package/services/inapp-notification-service/index.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_LISTEN_AVAIL_BRIDGE_CLAIM } from '@subwallet/extension-base/constants';
 import { fetchLastestRemindNotificationTime } from '@subwallet/extension-base/constants/remind-notification-time';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
@@ -11,7 +11,7 @@ import { NotificationDescriptionMap, NotificationTitleMap, ONE_DAY_MILLISECOND }
 import { NotificationActionType, NotificationTab } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
 import { AvailBridgeSourceChain, fetchAllAvailBridgeClaimable, fetchPolygonBridgeTransactions, hrsToMillisecond } from '@subwallet/extension-base/services/inapp-notification-service/utils';
 import { ProcessType, YieldPoolType } from '@subwallet/extension-base/types';
-import { categoryAddresses, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { formatNumber, getAddressesByChainType, reformatAddress } from '@subwallet/extension-base/utils';
 import { isSubstrateAddress } from '@subwallet/keyring';
 export class InappNotificationService {
   constructor(dbService, keyringService, eventService, chainService) {
@@ -170,12 +170,17 @@ export class InappNotificationService {
   }
   getCategorizedAddresses() {
     const addresses = this.keyringService.context.getAllAddresses();
-    return categoryAddresses(addresses);
+    const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
+    const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
+    return {
+      evmAddresses: evmAddresses,
+      substrateAddresses: substrateAddresses
+    };
   }
   createAvailBridgeClaimNotification() {
     const {
-      evm: evmAddresses,
-      substrate: substrateAddresses
+      evmAddresses,
+      substrateAddresses
     } = this.getCategorizedAddresses();
     const chainAssets = this.chainService.getAssetRegistry();
     let ASSET_TYPE;
@@ -262,7 +267,7 @@ export class InappNotificationService {
   // Polygon Claimable Handle
   async createPolygonClaimableTransactions() {
     const {
-      evm: evmAddresses
+      evmAddresses
     } = this.getCategorizedAddresses();
     const etherChains = [COMMON_ASSETS.ETH, COMMON_ASSETS.ETH_SEPOLIA];
     const polygonAssets = Object.values(this.chainService.getAssetRegistry()).filter(asset => etherChains.includes(asset.slug));
@@ -433,4 +438,7 @@ export class InappNotificationService {
   removeAccountNotifications(proxyId) {
     this.dbService.removeAccountNotifications(proxyId).catch(console.error);
   }
+  migrateNotificationProxyId(proxyIds, newProxyId, newName) {
+    this.dbService.updateNotificationProxyId(proxyIds, newProxyId, newName);
+  }
 }

package/services/keyring-service/context/account-context.d.ts

@@ -1,4 +1,4 @@
-import { AccountExternalError, RequestAccountCreateExternalV2, RequestAccountCreateHardwareMultiple, RequestAccountCreateHardwareV2, RequestAccountCreateWithSecretKey, RequestAccountExportPrivateKey, RequestChangeMasterPassword, RequestMigratePassword, ResponseAccountCreateWithSecretKey, ResponseAccountExportPrivateKey, ResponseChangeMasterPassword, ResponseMigratePassword } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountExternalError, RequestAccountCreateExternalV2, RequestAccountCreateHardwareMultiple, RequestAccountCreateHardwareV2, RequestAccountCreateWithSecretKey, RequestAccountExportPrivateKey, RequestChangeMasterPassword, RequestMigratePassword, RequestMigrateSoloAccount, RequestMigrateUnifiedAndFetchEligibleSoloAccounts, RequestPingSession, ResponseAccountCreateWithSecretKey, ResponseAccountExportPrivateKey, ResponseChangeMasterPassword, ResponseMigratePassword } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import { AccountProxyMap, CurrentAccountInfo, RequestAccountBatchExportV2, RequestAccountCreateSuriV2, RequestAccountNameValidate, RequestAccountProxyEdit, RequestAccountProxyForget, RequestBatchJsonGetAccountInfo, RequestBatchRestoreV2, RequestChangeTonWalletContractVersion, RequestCheckPublicAndSecretKey, RequestDeriveCreateMultiple, RequestDeriveCreateV3, RequestDeriveValidateV2, RequestExportAccountProxyMnemonic, RequestGetAllTonWalletContractVersion, RequestGetDeriveAccounts, RequestGetDeriveSuggestion, RequestJsonGetAccountInfo, RequestJsonRestoreV2, RequestMnemonicCreateV2, RequestMnemonicValidateV2, RequestPrivateKeyValidateV2, ResponseAccountBatchExportV2, ResponseAccountCreateSuriV2, ResponseAccountNameValidate, ResponseBatchJsonGetAccountInfo, ResponseCheckPublicAndSecretKey, ResponseDeriveValidateV2, ResponseExportAccountProxyMnemonic, ResponseGetAllTonWalletContractVersion, ResponseGetDeriveAccounts, ResponseGetDeriveSuggestion, ResponseJsonGetAccountInfo, ResponseMnemonicCreateV2, ResponseMnemonicValidateV2, ResponsePrivateKeyValidateV2 } from '@subwallet/extension-base/types';
@@ -15,6 +15,7 @@ export declare class AccountContext {
     private readonly ledgerHandler;
     private readonly modifyHandler;
     private readonly secretHandler;
+    private readonly migrationHandler;
     constructor(koniState: KoniState, parentService: KeyringService);
     get pairs(): SubjectInfo;
     get observable(): {
@@ -81,9 +82,12 @@ export declare class AccountContext {
     getListDeriveAccounts(request: RequestGetDeriveAccounts): ResponseGetDeriveAccounts;
     validateDerivePath(request: RequestDeriveValidateV2): ResponseDeriveValidateV2;
     getDeriveSuggestion(request: RequestGetDeriveSuggestion): ResponseGetDeriveSuggestion;
-    derivationAccountProxyCreate(request: RequestDeriveCreateV3): boolean;
+    derivationAccountProxyCreate(request: RequestDeriveCreateV3, isMigration?: boolean): boolean;
     addInjectAccounts(accounts: InjectedAccountWithMeta[]): void;
     removeInjectAccounts(_addresses: string[]): void;
+    migrateUnifiedAndFetchEligibleSoloAccounts(request: RequestMigrateUnifiedAndFetchEligibleSoloAccounts, setMigratingModeFn: () => void): Promise<import("@subwallet/extension-base/background/KoniTypes").ResponseMigrateUnifiedAndFetchEligibleSoloAccounts>;
+    migrateSoloAccount(request: RequestMigrateSoloAccount): import("@subwallet/extension-base/background/KoniTypes").ResponseMigrateSoloAccount;
+    pingSession(request: RequestPingSession): boolean;
     removeNoneHardwareGenesisHash(): void;
     updateMetadataForPair(): void;
     resetWallet(): void;

package/services/keyring-service/context/account-context.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+import { AccountMigrationHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Migration';
 import { AccountDeriveHandler, AccountInjectHandler, AccountJsonHandler, AccountLedgerHandler, AccountMnemonicHandler, AccountModifyHandler, AccountSecretHandler } from "./handlers/index.js";
 import { AccountState } from "./state.js";
 export class AccountContext {
@@ -15,6 +16,7 @@ export class AccountContext {
     this.ledgerHandler = new AccountLedgerHandler(this.parentService, this.state);
     this.modifyHandler = new AccountModifyHandler(this.parentService, this.state);
     this.secretHandler = new AccountSecretHandler(this.parentService, this.state);
+    this.migrationHandler = new AccountMigrationHandler(this.parentService, this.state);
   }
 
   // TODO: Merge to value
@@ -222,8 +224,8 @@ export class AccountContext {
   }
 
   /* Derive account proxy  */
-  derivationAccountProxyCreate(request) {
-    return this.deriveHandler.derivationAccountProxyCreate(request);
+  derivationAccountProxyCreate(request, isMigration) {
+    return this.deriveHandler.derivationAccountProxyCreate(request, isMigration);
   }
 
   /* Derive */
@@ -239,6 +241,19 @@ export class AccountContext {
 
   /* Inject */
 
+  /* Migration */
+  async migrateUnifiedAndFetchEligibleSoloAccounts(request, setMigratingModeFn) {
+    return await this.migrationHandler.migrateUnifiedAndFetchEligibleSoloAccounts(request, setMigratingModeFn);
+  }
+  migrateSoloAccount(request) {
+    return this.migrationHandler.migrateSoloToUnifiedAccount(request);
+  }
+  pingSession(request) {
+    return this.migrationHandler.pingSession(request);
+  }
+
+  /* Migration */
+
   /* Others */
 
   removeNoneHardwareGenesisHash() {

package/services/keyring-service/context/handlers/Derive.d.ts

@@ -25,5 +25,5 @@ export declare class AccountDeriveHandler extends AccountBaseHandler {
     /**
      * Derive account proxy
      *  */
-    derivationAccountProxyCreate(request: RequestDeriveCreateV3): boolean;
+    derivationAccountProxyCreate(request: RequestDeriveCreateV3, isMigration?: boolean): boolean;
 }

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

@@ -9,7 +9,7 @@ import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert } from '@polkadot/util';
 import { AccountBaseHandler } from "./Base.js";
-const validDeriveKeypairTypes = [...SubstrateKeypairTypes, ...EthereumKeypairTypes, 'ton'];
+const validDeriveKeypairTypes = [...SubstrateKeypairTypes, ...EthereumKeypairTypes, 'ton', 'cardano'];
 
 /**
  * @class AccountDeriveHandler
@@ -208,7 +208,7 @@ export class AccountDeriveHandler extends AccountBaseHandler {
   /**
    * Derive account proxy
    *  */
-  derivationAccountProxyCreate(request) {
+  derivationAccountProxyCreate(request, isMigration = false) {
     const {
       name,
       proxyId: deriveId,
@@ -219,7 +219,7 @@ export class AccountDeriveHandler extends AccountBaseHandler {
     const rootId = this.state.value.accounts[parentProxyId].parentId || parentProxyId;
     const rootProxyId = this.state.belongUnifiedAccount(rootId) || rootId;
     const nameExists = this.state.checkNameExists(name);
-    if (nameExists) {
+    if (nameExists && !isMigration) {
       throw new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
     }
     const validateRs = this.validateDerivePath({
@@ -343,11 +343,13 @@ export class AccountDeriveHandler extends AccountBaseHandler {
     }
     const addresses = pairs.map(pair => pair.address);
     const exists = this.state.checkAddressExists(addresses);
-    assert(!exists, t('Account already exists under the name "{{name}}"', {
-      replace: {
-        name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
-      }
-    }));
+    if (!isMigration) {
+      assert(!exists, t('Account already exists under the name "{{name}}"', {
+        replace: {
+          name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
+        }
+      }));
+    }
     childAccountProxy && this.state.upsertAccountProxyByKey(childAccountProxy);
     this.state.upsertModifyPairs(modifyPairs);
     for (const childPair of pairs) {

package/services/keyring-service/context/handlers/Migration.d.ts

@@ -0,0 +1,17 @@
+import { RequestMigrateSoloAccount, RequestMigrateUnifiedAndFetchEligibleSoloAccounts, RequestPingSession, ResponseMigrateSoloAccount, ResponseMigrateUnifiedAndFetchEligibleSoloAccounts, SoloAccountToBeMigrated } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountBaseHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Base';
+import { AccountProxy } from '@subwallet/extension-base/types';
+export declare const SESSION_TIMEOUT = 10000;
+export declare class AccountMigrationHandler extends AccountBaseHandler {
+    private sessionIdToPassword;
+    pingSession({ sessionId }: RequestPingSession): boolean;
+    migrateUnifiedAndFetchEligibleSoloAccounts(request: RequestMigrateUnifiedAndFetchEligibleSoloAccounts, setMigratingModeFn: () => void): Promise<ResponseMigrateUnifiedAndFetchEligibleSoloAccounts>;
+    migrateUnifiedToUnifiedAccount(password: string, accountProxies: AccountProxy[], setMigratingModeFn: () => void): Promise<string[]>;
+    getUACanBeMigrated(accountProxies: AccountProxy[]): AccountProxy[];
+    getSoloAccountsNeedToBeMigrated(accountProxies: AccountProxy[]): AccountProxy[];
+    groupSoloAccountByMnemonic(password: string, accountProxies: AccountProxy[]): Record<string, AccountProxy[]>;
+    accountProxiesToEligibleSoloAccountMap(accountProxyMap: Record<string, AccountProxy[]>): Record<string, SoloAccountToBeMigrated[]>;
+    sortUAByParent(accountProxies: AccountProxy[]): AccountProxy[];
+    migrateSoloToUnifiedAccount(request: RequestMigrateSoloAccount): ResponseMigrateSoloAccount;
+    migrateDerivedSoloAccountRelationship(soloAccounts: SoloAccountToBeMigrated[]): void;
+}

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

@@ -0,0 +1,258 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountBaseHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Base';
+import { AccountChainType, SUPPORTED_ACCOUNT_CHAIN_TYPES } from '@subwallet/extension-base/types';
+import { createAccountProxyId, getDefaultKeypairTypeFromAccountChainType, getSuri } from '@subwallet/extension-base/utils';
+import { generateRandomString } from '@subwallet/extension-base/utils/getId';
+import { keyring } from '@subwallet/ui-keyring';
+import { keyExtractSuri } from '@polkadot/util-crypto';
+export const SESSION_TIMEOUT = 10000;
+export class AccountMigrationHandler extends AccountBaseHandler {
+  sessionIdToPassword = {};
+  pingSession({
+    sessionId
+  }) {
+    if (!this.sessionIdToPassword[sessionId]) {
+      // todo: if no persistent sessionId, should we jump to enter password again?
+      throw Error(`Session ID ${sessionId} not found.`);
+    }
+    clearTimeout(this.sessionIdToPassword[sessionId].timeoutId);
+    this.sessionIdToPassword[sessionId].timeoutId = setTimeout(() => {
+      delete this.sessionIdToPassword[sessionId];
+    }, SESSION_TIMEOUT);
+    return true;
+  }
+  async migrateUnifiedAndFetchEligibleSoloAccounts(request, setMigratingModeFn) {
+    // Migrate unified -> unified
+    const password = request.password;
+    const allAccountProxies = Object.values(this.state.accounts);
+    const UACanBeMigrated = this.getUACanBeMigrated(allAccountProxies);
+    const UACanBeMigratedSortedByParent = this.sortUAByParent(UACanBeMigrated); // master account must be migrated before derived account
+    const migratedUnifiedAccountIds = await this.migrateUnifiedToUnifiedAccount(password, UACanBeMigratedSortedByParent, setMigratingModeFn);
+
+    // Get solo accounts can be migrated
+    const soloAccountsNeedToBeMigrated = this.getSoloAccountsNeedToBeMigrated(allAccountProxies);
+    const soloAccountsNeedToBeMigratedGroup = this.groupSoloAccountByMnemonic(password, soloAccountsNeedToBeMigrated);
+    const eligibleSoloAccountMap = this.accountProxiesToEligibleSoloAccountMap(soloAccountsNeedToBeMigratedGroup);
+
+    // Create persistent mapping sessionId <-> password
+    const uniqueId = Date.now().toString();
+    const timeoutId = setTimeout(() => delete this.sessionIdToPassword[uniqueId], SESSION_TIMEOUT * 2);
+    this.sessionIdToPassword[uniqueId] = {
+      password,
+      timeoutId
+    };
+    return {
+      migratedUnifiedAccountIds,
+      soloAccounts: eligibleSoloAccountMap,
+      sessionId: uniqueId
+    };
+  }
+  async migrateUnifiedToUnifiedAccount(password, accountProxies, setMigratingModeFn) {
+    keyring.unlockKeyring(password);
+    this.parentService.updateKeyringState();
+    setMigratingModeFn();
+    const unifiedAccountIds = [];
+    const modifiedPairs = structuredClone(this.state.modifyPairs);
+    const {
+      derivedUnifiedAccounts,
+      masterUnifiedAccounts
+    } = accountProxies.reduce((accountInfo, account) => {
+      const isDerivedAccount = !!account.parentId;
+      isDerivedAccount ? accountInfo.derivedUnifiedAccounts.push(account) : accountInfo.masterUnifiedAccounts.push(account);
+      return accountInfo;
+    }, {
+      derivedUnifiedAccounts: [],
+      masterUnifiedAccounts: []
+    });
+    try {
+      for (const unifiedAccount of masterUnifiedAccounts) {
+        const proxyId = unifiedAccount.id;
+        const mnemonic = this.parentService.context.exportAccountProxyMnemonic({
+          password,
+          proxyId
+        }).result;
+        const newChainTypes = Object.values(AccountChainType).filter(type => !unifiedAccount.chainTypes.includes(type) && SUPPORTED_ACCOUNT_CHAIN_TYPES.includes(type));
+        const keypairTypes = newChainTypes.map(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
+        keypairTypes.forEach(type => {
+          const suri = getSuri(mnemonic, type);
+          const pair = keyring.createFromUri(suri, {}, type);
+          const address = pair.address;
+          modifiedPairs[address] = {
+            accountProxyId: proxyId,
+            migrated: true,
+            key: address
+          };
+        });
+        keypairTypes.forEach(type => {
+          const suri = getSuri(mnemonic, type);
+          const {
+            derivePath
+          } = keyExtractSuri(suri);
+          const metadata = {
+            name: unifiedAccount.name,
+            derivationPath: derivePath ? derivePath.substring(1) : undefined
+          };
+          const rs = keyring.addUri(suri, metadata, type);
+          const address = rs.pair.address;
+          this.state._addAddressToAuthList(address, true);
+        });
+        this.state.upsertModifyPairs(modifiedPairs);
+        unifiedAccountIds.push(proxyId);
+      }
+      await new Promise(resolve => setTimeout(resolve, 1800)); // Wait last master unified account migrated. // todo: can be optimized later by await a promise resolve if master account is migrating
+
+      for (const unifiedAccount of derivedUnifiedAccounts) {
+        this.parentService.context.derivationAccountProxyCreate({
+          name: unifiedAccount.name,
+          suri: unifiedAccount.suri || '',
+          proxyId: unifiedAccount.parentId || ''
+        }, true);
+        unifiedAccountIds.push(unifiedAccount.id);
+      }
+    } catch (error) {
+      console.error('Migration unified account failed with error:', error);
+    } finally {
+      keyring.lockAll(false);
+      this.parentService.updateKeyringState();
+    }
+    return unifiedAccountIds;
+  }
+  getUACanBeMigrated(accountProxies) {
+    return accountProxies.filter(account => this.state.isUnifiedAccount(account.id) && account.isNeedMigrateUnifiedAccount);
+  }
+  getSoloAccountsNeedToBeMigrated(accountProxies) {
+    return accountProxies.filter(account => !this.state.isUnifiedAccount(account.id) && account.isNeedMigrateUnifiedAccount);
+  }
+  groupSoloAccountByMnemonic(password, accountProxies) {
+    const parentService = this.parentService;
+    return accountProxies.reduce(function (rs, item) {
+      const oldProxyId = item.id;
+      const mnemonic = parentService.context.exportAccountProxyMnemonic({
+        password,
+        proxyId: oldProxyId
+      }).result;
+      const upcomingProxyId = createAccountProxyId(mnemonic);
+      if (!rs[upcomingProxyId]) {
+        rs[upcomingProxyId] = [];
+      }
+      rs[upcomingProxyId].push(item);
+      return rs;
+    }, {});
+  }
+  accountProxiesToEligibleSoloAccountMap(accountProxyMap) {
+    const eligibleSoloAccountMap = {};
+    Object.entries(accountProxyMap).forEach(([upcomingProxyId, accounts]) => {
+      eligibleSoloAccountMap[upcomingProxyId] = accounts.map(account => {
+        return {
+          upcomingProxyId,
+          proxyId: account.accounts[0].proxyId,
+          address: account.accounts[0].address,
+          name: account.name,
+          chainType: account.chainTypes[0]
+        };
+      });
+    });
+    return eligibleSoloAccountMap;
+  }
+  sortUAByParent(accountProxies) {
+    const undefinedToStr = str => str !== null && str !== void 0 ? str : '';
+    return accountProxies.sort((a, b) => undefinedToStr(a.parentId) < undefinedToStr(b.parentId) ? -1 : undefinedToStr(a.parentId) > undefinedToStr(b.parentId) ? 1 : 0);
+  }
+  migrateSoloToUnifiedAccount(request) {
+    const {
+      accountName,
+      sessionId,
+      soloAccounts
+    } = request;
+    const password = this.sessionIdToPassword[sessionId].password;
+    keyring.unlockKeyring(password);
+    this.parentService.updateKeyringState();
+    const modifiedPairs = structuredClone(this.state.modifyPairs);
+    const firstAccountInfo = soloAccounts[0];
+    const upcomingProxyId = firstAccountInfo.upcomingProxyId;
+    const firstAccountOldProxyId = firstAccountInfo.proxyId;
+    try {
+      const mnemonic = this.parentService.context.exportAccountProxyMnemonic({
+        password,
+        proxyId: firstAccountOldProxyId
+      }).result;
+      const keypairTypes = SUPPORTED_ACCOUNT_CHAIN_TYPES.map(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
+      keypairTypes.forEach(type => {
+        const suri = getSuri(mnemonic, type);
+        const pair = keyring.createFromUri(suri, {}, type);
+        const address = pair.address;
+        modifiedPairs[address] = {
+          accountProxyId: upcomingProxyId,
+          migrated: true,
+          key: address
+        };
+      });
+      this.state.upsertAccountProxyByKey({
+        id: upcomingProxyId,
+        name: accountName,
+        isMigrationDone: false
+      });
+      const soloAccountProxyIds = [];
+      keypairTypes.forEach(type => {
+        const suri = getSuri(mnemonic, type);
+        const {
+          derivePath
+        } = keyExtractSuri(suri);
+        const metadata = {
+          name: accountName.concat(' - ').concat(generateRandomString()),
+          derivationPath: derivePath ? derivePath.substring(1) : undefined
+        };
+        const rs = keyring.addUri(suri, metadata, type);
+        soloAccountProxyIds.push(rs.json.address);
+        const address = rs.pair.address;
+        this.state._addAddressToAuthList(address, true);
+      });
+      this.state.upsertModifyPairs(modifiedPairs);
+      this.migrateDerivedSoloAccountRelationship(soloAccounts);
+      this.state.upsertAccountProxyByKey({
+        id: upcomingProxyId,
+        name: accountName,
+        isMigrationDone: true
+      });
+
+      // Re-update account name
+      soloAccountProxyIds.forEach(oldProxyId => {
+        const pair = keyring.getPair(oldProxyId);
+        keyring.saveAccountMeta(pair, {
+          ...pair.meta,
+          name: accountName
+        });
+      });
+
+      // Update current account after migrating
+      const currentAccountProxyId = this.state.currentAccount.proxyId;
+      if (soloAccountProxyIds.includes(currentAccountProxyId)) {
+        this.state.saveCurrentAccountProxyId(upcomingProxyId);
+      }
+    } catch (error) {
+      console.error('Migration solo account failed with error', error);
+    } finally {
+      keyring.lockAll(false);
+      this.parentService.updateKeyringState();
+    }
+    return {
+      migratedUnifiedAccountId: upcomingProxyId
+    };
+  }
+  migrateDerivedSoloAccountRelationship(soloAccounts) {
+    const accountProxies = this.state.accountProxies;
+
+    // Use Set.has & Map.get to optimize search performance
+    const proxyIdsSet = new Set(soloAccounts.map(account => account.proxyId));
+    const proxyIdToUpcomingProxyIdMap = new Map(soloAccounts.map(account => [account.proxyId, account.upcomingProxyId]));
+    for (const account of Object.values(accountProxies)) {
+      const currentParent = account.parentId;
+      if (currentParent && proxyIdsSet.has(currentParent)) {
+        accountProxies[account.id].parentId = proxyIdToUpcomingProxyIdMap.get(currentParent);
+      }
+    }
+    this.state.upsertAccountProxy(accountProxies);
+  }
+}

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

@@ -27,7 +27,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     mnemonic: _seed,
     type = 'general'
   }) {
-    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton'] : ['ton-native'];
+    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton', 'cardano'] : ['ton-native'];
     const seed = _seed || type === 'general' ? mnemonicGenerate(length) : await tonMnemonicGenerate(length);
     const rs = {
       mnemonic: seed,
@@ -97,7 +97,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     const addressDict = {};
     let changedAccount = false;
     const hasMasterPassword = keyring.keyring.hasMasterPassword;
-    const types = type ? [type] : ['sr25519', 'ethereum', 'ton'];
+    const types = type ? [type] : ['sr25519', 'ethereum', 'ton', 'cardano'];
     if (!hasMasterPassword) {
       if (!password) {
         throw Error(t('The password of each account is needed to set up master password'));

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

@@ -5,7 +5,7 @@ import { AccountExternalErrorCode } from '@subwallet/extension-base/background/K
 import { AccountChainType, CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
 import { decodePair } from '@subwallet/keyring/pair/decode';
-import { BitcoinKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert, hexStripPrefix, hexToU8a, isHex, u8aToHex } from '@polkadot/util';
@@ -49,7 +49,7 @@ export class AccountSecretHandler extends AccountBaseHandler {
         isReadOnly,
         genesisHash: ''
       };
-      if ([...BitcoinKeypairTypes, ...TonKeypairTypes].includes(type) && isReadOnly) {
+      if ([...BitcoinKeypairTypes, ...TonKeypairTypes, ...CardanoKeypairTypes].includes(type) && isReadOnly) {
         meta.noPublicKey = true;
       }
       const result = keyring.keyring.addFromAddress(address, meta, null, type);

package/services/keyring-service/utils.d.ts

@@ -0,0 +1,2 @@
+import { AccountProxy } from '@subwallet/extension-base/types';
+export declare const hasAnyAccountForMigration: (allAccountProxies: AccountProxy[]) => boolean;

package/services/keyring-service/utils.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const hasAnyAccountForMigration = allAccountProxies => {
+  for (const account of allAccountProxies) {
+    if (account.isNeedMigrateUnifiedAccount) {
+      return true;
+    }
+  }
+  return false;
+};

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

@@ -0,0 +1,16 @@
+import { ConfirmationDefinitionsCardano, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationTypeCardano, RequestConfirmationCompleteCardano } from '@subwallet/extension-base/background/KoniTypes';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { BehaviorSubject } from 'rxjs';
+export default class CardanoRequestHandler {
+    #private;
+    private readonly confirmationsQueueSubjectCardano;
+    private readonly confirmationsPromiseMap;
+    constructor(requestService: RequestService);
+    get numCardanoRequests(): number;
+    getConfirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
+    addConfirmationCardano<CT extends ConfirmationTypeCardano>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsCardano[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsCardano[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsCardano[CT][1]>;
+    completeConfirmationCardano(request: RequestConfirmationCompleteCardano): Promise<boolean>;
+    private decorateResult;
+    private signTransactionCardano;
+    resetWallet(): void;
+}