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

package/cjs/services/fee-service/service.js

@@ -15,7 +15,8 @@ class FeeService {
   chainFeeSubscriptionMap = {
     evm: {},
     substrate: {},
-    ton: {}
+    ton: {},
+    cardano: {}
   };
   constructor(state) {
     this.state = state;
@@ -109,21 +110,31 @@ class FeeService {
             const api = this.state.getEvmApi(chain);
 
             // TODO: Handle case type === evm and not have api
-            if (type === 'evm' && api) {
-              (0, _utils2.calculateGasFeeParams)(api, chain).then(info => {
-                observer.next(info);
-              }).catch(e => {
-                console.warn(`Cannot get fee param for ${chain}`, e);
+            if (type === 'evm') {
+              if (api) {
+                (0, _utils2.calculateGasFeeParams)(api, chain).then(info => {
+                  observer.next(info);
+                }).catch(e => {
+                  console.warn(`Cannot get fee param for ${chain}`, e);
+                  observer.next({
+                    type: 'evm',
+                    gasPrice: '0',
+                    baseGasFee: undefined,
+                    options: undefined
+                  });
+                });
+              } else {
+                console.warn(`Cannot get fee param for ${chain}`, 'Cannot get api');
                 observer.next({
                   type: 'evm',
                   gasPrice: '0',
                   baseGasFee: undefined,
                   options: undefined
                 });
-              });
+              }
             } else {
               observer.next({
-                type: type,
+                type,
                 busyNetwork: false,
                 options: {
                   slow: {

package/cjs/services/fee-service/utils/tokenPayFee.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.batchExtrinsicSetFeeHydration = batchExtrinsicSetFeeHydration;
+exports.getAssetHubTokensCanPayFee = getAssetHubTokensCanPayFee;
+exports.getHydrationRate = getHydrationRate;
+exports.getHydrationTokensCanPayFee = getHydrationTokensCanPayFee;
+var _types = require("@subwallet/chain-list/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/handler/asset-hub/utils");
+var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-sdk"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function getAssetHubTokensCanPayFee(request) {
+  const {
+    chainService,
+    feeAmount,
+    nativeBalanceInfo,
+    nativeTokenInfo,
+    substrateApi,
+    tokensHasBalanceInfoMap
+  } = request;
+  const tokensList = [nativeBalanceInfo];
+  if (!(nativeTokenInfo.metadata && nativeTokenInfo.metadata.multilocation)) {
+    return tokensList;
+  }
+
+  // ensure nativeTokenInfo and localTokenInfo have multi-location metadata beforehand to improve performance.
+  const tokensHasBalanceSlug = Object.keys(tokensHasBalanceInfoMap);
+  const tokenInfos = tokensHasBalanceSlug.map(tokenSlug => chainService.getAssetBySlug(tokenSlug)).filter(token => token.originChain === substrateApi.chainSlug && token.assetType !== _types._AssetType.NATIVE && token.metadata && token.metadata.multilocation);
+  await Promise.all(tokenInfos.map(async tokenInfo => {
+    try {
+      const tokenSlug = tokenInfo.slug;
+      const reserve = await (0, _utils2.getReserveForPool)(substrateApi.api, nativeTokenInfo, tokenInfo);
+      if (!reserve || !reserve[0] || !reserve[1] || reserve[0] === '0' || reserve[1] === '0') {
+        return;
+      }
+      const rate = new _bignumber.default(reserve[1]).div(reserve[0]).toFixed();
+      const tokenCanPayFee = {
+        slug: tokenSlug,
+        free: tokensHasBalanceInfoMap[tokenSlug].free,
+        rate
+      };
+      if (feeAmount === undefined) {
+        tokensList.push(tokenCanPayFee);
+      } else {
+        const amount = (0, _utils2.estimateTokensForPool)(feeAmount, reserve);
+        const liquidityError = (0, _utils2.checkLiquidityForPool)(amount, reserve[0], reserve[1]);
+        if (!liquidityError) {
+          tokensList.push(tokenCanPayFee);
+        }
+      }
+    } catch (e) {
+      console.error('error when fetching pool with token', tokenInfo.slug, e);
+    }
+  }));
+  return tokensList;
+}
+async function getHydrationTokensCanPayFee(request) {
+  const {
+    address,
+    chainService,
+    nativeBalanceInfo,
+    nativeTokenInfo,
+    substrateApi,
+    tokensHasBalanceInfoMap
+  } = request;
+  const tokensList = [nativeBalanceInfo];
+  const _acceptedCurrencies = await substrateApi.api.query.multiTransactionPayment.acceptedCurrencies.entries();
+  const supportedAssetIds = _acceptedCurrencies.map(_assetId => {
+    const assetId = _assetId[0].toHuman();
+    return assetId[0].replaceAll(',', '');
+  });
+  const nativePriceId = (0, _utils._getAssetPriceId)(nativeTokenInfo);
+  if (!nativePriceId) {
+    return tokensList;
+  }
+  const tokenInfos = Object.keys(tokensHasBalanceInfoMap).map(tokenSlug => chainService.getAssetBySlug(tokenSlug)).filter(token => token.originChain === substrateApi.chainSlug && token.assetType !== _types._AssetType.NATIVE && !!token.metadata && !!token.metadata.assetId);
+  await Promise.all(tokenInfos.map(async tokenInfo => {
+    const priceId = (0, _utils._getAssetPriceId)(tokenInfo);
+    const rate = await getHydrationRate(address, nativeTokenInfo, tokenInfo);
+    if (priceId && rate) {
+      if (supportedAssetIds.includes((0, _utils._getTokenOnChainAssetId)(tokenInfo))) {
+        tokensList.push({
+          slug: tokenInfo.slug,
+          free: tokensHasBalanceInfoMap[tokenInfo.slug].free,
+          rate: rate.toString()
+        });
+      }
+    }
+  }));
+  return tokensList;
+}
+function batchExtrinsicSetFeeHydration(substrateApi, tx, feeSetting, assetId) {
+  const api = substrateApi.api;
+  const isSettingLocalFee = feeSetting && feeSetting !== 0;
+  const isAttendToSetLocalFee = assetId && assetId !== '0';
+  if (!tx) {
+    return tx;
+  }
+
+  // current native - set native
+  if (!isSettingLocalFee && !isAttendToSetLocalFee) {
+    return tx;
+  }
+
+  // current native - set local
+  if (!isSettingLocalFee && isAttendToSetLocalFee) {
+    return api.tx.utility.batchAll([api.tx.multiTransactionPayment.setCurrency(assetId), tx, api.tx.multiTransactionPayment.setCurrency('0')]);
+  }
+
+  // current local - set native
+  if (isSettingLocalFee && !isAttendToSetLocalFee) {
+    return api.tx.utility.batchAll([api.tx.multiTransactionPayment.setCurrency('0'), tx]);
+  }
+
+  // current local - set local
+  if (isSettingLocalFee && isAttendToSetLocalFee) {
+    if (assetId === feeSetting.toString()) {
+      // current local = set local
+      return api.tx.utility.batchAll([tx, api.tx.multiTransactionPayment.setCurrency('0')]);
+    } else {
+      // current local != set local
+      return api.tx.utility.batchAll([api.tx.multiTransactionPayment.setCurrency(assetId), tx, api.tx.multiTransactionPayment.setCurrency('0')]);
+    }
+  }
+  return tx;
+}
+async function getHydrationRate(address, hdx, desToken) {
+  var _subwalletApiSdk$swap;
+  const quoteRate = await ((_subwalletApiSdk$swap = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.getHydrationRate({
+    address,
+    pair: {
+      slug: `${hdx.slug}___${desToken.slug}`,
+      from: hdx.slug,
+      to: desToken.slug
+    }
+  }));
+  if (!quoteRate) {
+    return undefined;
+  } else {
+    const hdxDecimal = (0, _utils._getAssetDecimals)(hdx);
+    const desTokenDecimal = (0, _utils._getAssetDecimals)(desToken);
+    return new _bignumber.default(quoteRate).multipliedBy(10 ** (desTokenDecimal - hdxDecimal)).toFixed();
+  }
+}

package/cjs/services/history-service/index.js

@@ -151,19 +151,17 @@ class HistoryService {
   }
   subscribeHistories(chain, proxyId, cb) {
     const addresses = this.keyringService.context.getDecodedAddresses(proxyId, false);
-    const {
-      evm,
-      substrate
-    } = (0, _utils2.categoryAddresses)(addresses);
+    const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+    const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
     const subscription = this.historySubject.subscribe(items => {
       cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
     const chainInfo = this.chainService.getChainInfoByKey(chain);
     if ((0, _utils._isChainSubstrateCompatible)(chainInfo)) {
       if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
-        this.fetchSubscanTransactionHistory(chain, evm);
+        this.fetchSubscanTransactionHistory(chain, evmAddresses);
       } else {
-        this.fetchSubscanTransactionHistory(chain, substrate);
+        this.fetchSubscanTransactionHistory(chain, substrateAddresses);
       }
     }
     return {

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

@@ -177,12 +177,17 @@ class InappNotificationService {
   }
   getCategorizedAddresses() {
     const addresses = this.keyringService.context.getAllAddresses();
-    return (0, _utils2.categoryAddresses)(addresses);
+    const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+    const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.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;
@@ -269,7 +274,7 @@ class InappNotificationService {
   // Polygon Claimable Handle
   async createPolygonClaimableTransactions() {
     const {
-      evm: evmAddresses
+      evmAddresses
     } = this.getCategorizedAddresses();
     const etherChains = [_chainList.COMMON_ASSETS.ETH, _chainList.COMMON_ASSETS.ETH_SEPOLIA];
     const polygonAssets = Object.values(this.chainService.getAssetRegistry()).filter(asset => etherChains.includes(asset.slug));
@@ -440,5 +445,8 @@ class InappNotificationService {
   removeAccountNotifications(proxyId) {
     this.dbService.removeAccountNotifications(proxyId).catch(console.error);
   }
+  migrateNotificationProxyId(proxyIds, newProxyId, newName) {
+    this.dbService.updateNotificationProxyId(proxyIds, newProxyId, newName);
+  }
 }
 exports.InappNotificationService = InappNotificationService;

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AccountContext = void 0;
+var _Migration = require("@subwallet/extension-base/services/keyring-service/context/handlers/Migration");
 var _handlers = require("./handlers");
 var _state = require("./state");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -21,6 +22,7 @@ class AccountContext {
     this.ledgerHandler = new _handlers.AccountLedgerHandler(this.parentService, this.state);
     this.modifyHandler = new _handlers.AccountModifyHandler(this.parentService, this.state);
     this.secretHandler = new _handlers.AccountSecretHandler(this.parentService, this.state);
+    this.migrationHandler = new _Migration.AccountMigrationHandler(this.parentService, this.state);
   }
 
   // TODO: Merge to value
@@ -230,8 +232,8 @@ class AccountContext {
   }
 
   /* Derive account proxy  */
-  derivationAccountProxyCreate(request) {
-    return this.deriveHandler.derivationAccountProxyCreate(request);
+  derivationAccountProxyCreate(request, isMigration) {
+    return this.deriveHandler.derivationAccountProxyCreate(request, isMigration);
   }
 
   /* Derive */
@@ -247,6 +249,19 @@ 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/cjs/services/keyring-service/context/handlers/Derive.js

@@ -15,7 +15,7 @@ var _Base = require("./Base");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const validDeriveKeypairTypes = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes, 'ton'];
+const validDeriveKeypairTypes = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes, 'ton', 'cardano'];
 
 /**
  * @class AccountDeriveHandler
@@ -220,6 +220,7 @@ class AccountDeriveHandler extends _Base.AccountBaseHandler {
    * Derive account proxy
    *  */
   derivationAccountProxyCreate(request) {
+    let isMigration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       name,
       proxyId: deriveId,
@@ -230,7 +231,7 @@ class AccountDeriveHandler extends _Base.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 _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
     }
     const validateRs = this.validateDerivePath({
@@ -354,11 +355,13 @@ class AccountDeriveHandler extends _Base.AccountBaseHandler {
     }
     const addresses = pairs.map(pair => pair.address);
     const exists = this.state.checkAddressExists(addresses);
-    (0, _util.assert)(!exists, (0, _i18next.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) {
+      (0, _util.assert)(!exists, (0, _i18next.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/cjs/services/keyring-service/context/handlers/Migration.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SESSION_TIMEOUT = exports.AccountMigrationHandler = void 0;
+var _Base = require("@subwallet/extension-base/services/keyring-service/context/handlers/Base");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const SESSION_TIMEOUT = 10000;
+exports.SESSION_TIMEOUT = SESSION_TIMEOUT;
+class AccountMigrationHandler extends _Base.AccountBaseHandler {
+  sessionIdToPassword = {};
+  pingSession(_ref) {
+    let {
+      sessionId
+    } = _ref;
+    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) {
+    _uiKeyring.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(_types.AccountChainType).filter(type => !unifiedAccount.chainTypes.includes(type) && _types.SUPPORTED_ACCOUNT_CHAIN_TYPES.includes(type));
+        const keypairTypes = newChainTypes.map(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
+        keypairTypes.forEach(type => {
+          const suri = (0, _utils.getSuri)(mnemonic, type);
+          const pair = _uiKeyring.keyring.createFromUri(suri, {}, type);
+          const address = pair.address;
+          modifiedPairs[address] = {
+            accountProxyId: proxyId,
+            migrated: true,
+            key: address
+          };
+        });
+        keypairTypes.forEach(type => {
+          const suri = (0, _utils.getSuri)(mnemonic, type);
+          const {
+            derivePath
+          } = (0, _utilCrypto.keyExtractSuri)(suri);
+          const metadata = {
+            name: unifiedAccount.name,
+            derivationPath: derivePath ? derivePath.substring(1) : undefined
+          };
+          const rs = _uiKeyring.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 {
+      _uiKeyring.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 = (0, _utils.createAccountProxyId)(mnemonic);
+      if (!rs[upcomingProxyId]) {
+        rs[upcomingProxyId] = [];
+      }
+      rs[upcomingProxyId].push(item);
+      return rs;
+    }, {});
+  }
+  accountProxiesToEligibleSoloAccountMap(accountProxyMap) {
+    const eligibleSoloAccountMap = {};
+    Object.entries(accountProxyMap).forEach(_ref2 => {
+      let [upcomingProxyId, accounts] = _ref2;
+      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;
+    _uiKeyring.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 = _types.SUPPORTED_ACCOUNT_CHAIN_TYPES.map(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
+      keypairTypes.forEach(type => {
+        const suri = (0, _utils.getSuri)(mnemonic, type);
+        const pair = _uiKeyring.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 = (0, _utils.getSuri)(mnemonic, type);
+        const {
+          derivePath
+        } = (0, _utilCrypto.keyExtractSuri)(suri);
+        const metadata = {
+          name: accountName.concat(' - ').concat((0, _getId.generateRandomString)()),
+          derivationPath: derivePath ? derivePath.substring(1) : undefined
+        };
+        const rs = _uiKeyring.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 = _uiKeyring.keyring.getPair(oldProxyId);
+        _uiKeyring.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 {
+      _uiKeyring.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);
+  }
+}
+exports.AccountMigrationHandler = AccountMigrationHandler;

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

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

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

@@ -55,7 +55,7 @@ class AccountSecretHandler extends _Base.AccountBaseHandler {
         isReadOnly,
         genesisHash: ''
       };
-      if ([..._types2.BitcoinKeypairTypes, ..._types2.TonKeypairTypes].includes(type) && isReadOnly) {
+      if ([..._types2.BitcoinKeypairTypes, ..._types2.TonKeypairTypes, ..._types2.CardanoKeypairTypes].includes(type) && isReadOnly) {
         meta.noPublicKey = true;
       }
       const result = _uiKeyring.default.keyring.addFromAddress(address, meta, null, type);

package/cjs/services/keyring-service/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasAnyAccountForMigration = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const hasAnyAccountForMigration = allAccountProxies => {
+  for (const account of allAccountProxies) {
+    if (account.isNeedMigrateUnifiedAccount) {
+      return true;
+    }
+  }
+  return false;
+};
+exports.hasAnyAccountForMigration = hasAnyAccountForMigration;