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

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;

package/cjs/services/request-service/handler/CardanoRequestHandler.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _i18next = require("i18next");
+var _rxjs = require("rxjs");
+var _logger = require("@polkadot/util/logger");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class CardanoRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubjectCardano = new _rxjs.BehaviorSubject({
+    cardanoSignatureRequest: {},
+    cardanoSendTransactionRequest: {},
+    cardanoWatchTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = (0, _logger.logger)('CardanoRequestHandler');
+  }
+  get numCardanoRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectCardano.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectCardano() {
+    return this.confirmationsQueueSubjectCardano;
+  }
+  async addConfirmationCardano(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify({});
+    const isInternal = (0, _request.isInternalRequest)(url);
+    if (['cardanoSendTransactionRequest', 'cardanoSignatureRequest'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Cardano duplicate request'); // update this message.
+    }
+
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectCardano.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async completeConfirmationCardano(request) {
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error((0, _i18next.t)('Unable to proceed. Please try again'), type, id);
+        throw new Error((0, _i18next.t)('Unable to proceed. Please try again'));
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(type, confirmation, result);
+
+      // Validate response from confirmation popup some info like password, response format....
+      const error = validator && validator(result);
+      if (error) {
+        resolver.reject(error);
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectCardano.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+
+    // TODO: Review later
+    return true;
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'cardanoSignatureRequest') {
+        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+      } else if (t === 'cardanoSendTransactionRequest') {
+        result.payload = this.signTransactionCardano(request);
+      }
+      if (t === 'cardanoSignatureRequest' || t === 'cardanoSendTransactionRequest') {
+        const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+        if (isAlwaysRequired) {
+          this.#requestService.keyringService.lock();
+        }
+      }
+    }
+  }
+  signTransactionCardano(confirmation) {
+    // alibaba
+    const transaction = confirmation.payload;
+    const {
+      cardanoPayload,
+      from
+    } = transaction;
+    const pair = _uiKeyring.keyring.getPair(from);
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    return pair.cardano.sign(cardanoPayload);
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectCardano.next(confirmations);
+  }
+}
+exports.default = CardanoRequestHandler;

package/cjs/services/request-service/handler/EvmRequestHandler.js

@@ -88,7 +88,7 @@ class EvmRequestHandler {
     }
     if (options.isPassConfirmation) {
       await this.completeConfirmation({
-        evmSendTransactionRequest: {
+        [type]: {
           id,
           url,
           isApproved: true,

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _CardanoRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler"));
 var _TonRequestHandler = _interopRequireDefault(require("./handler/TonRequestHandler"));
 var _handler = require("./handler");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -19,6 +20,7 @@ class RequestService {
   #substrateRequestHandler;
   #evmRequestHandler;
   #tonRequestHandler;
+  #cardanoRequestHandler;
   #connectWCRequestHandler;
   #notSupportWCRequestHandler;
 
@@ -33,6 +35,7 @@ class RequestService {
     this.#substrateRequestHandler = new _handler.SubstrateRequestHandler(this);
     this.#evmRequestHandler = new _handler.EvmRequestHandler(this);
     this.#tonRequestHandler = new _TonRequestHandler.default(this);
+    this.#cardanoRequestHandler = new _CardanoRequestHandler.default(this);
     this.#connectWCRequestHandler = new _handler.ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new _handler.NotSupportWCRequestHandler(this);
 
@@ -40,7 +43,7 @@ class RequestService {
     this.updateIconV2();
   }
   get numAllRequests() {
-    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests;
+    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests;
   }
   updateIconV2(shouldClose) {
     this.#popupHandler.updateIconV2(shouldClose);
@@ -150,12 +153,18 @@ class RequestService {
   get numTonRequests() {
     return this.#tonRequestHandler.numTonRequests;
   }
+  get numCardanoRequests() {
+    return this.#cardanoRequestHandler.numCardanoRequests;
+  }
   get confirmationsQueueSubject() {
     return this.#evmRequestHandler.getConfirmationsQueueSubject();
   }
   get confirmationsQueueSubjectTon() {
     return this.#tonRequestHandler.getConfirmationsQueueSubjectTon();
   }
+  get confirmationsQueueSubjectCardano() {
+    return this.#cardanoRequestHandler.getConfirmationsQueueSubjectCardano();
+  }
   getSignRequest(id) {
     return this.#substrateRequestHandler.getSignRequest(id);
   }
@@ -172,12 +181,20 @@ class RequestService {
     let validator = arguments.length > 5 ? arguments[5] : undefined;
     return this.#tonRequestHandler.addConfirmationTon(id, url, type, payload, options, validator);
   }
+  addConfirmationCardano(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    return this.#cardanoRequestHandler.addConfirmationCardano(id, url, type, payload, options, validator);
+  }
   async completeConfirmation(request) {
     return await this.#evmRequestHandler.completeConfirmation(request);
   }
   async completeConfirmationTon(request) {
     return await this.#tonRequestHandler.completeConfirmationTon(request);
   }
+  async completeConfirmationCardano(request) {
+    return await this.#cardanoRequestHandler.completeConfirmationCardano(request);
+  }
   updateConfirmation(id, type, payload) {
     let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     let validator = arguments.length > 4 ? arguments[4] : undefined;
@@ -220,13 +237,14 @@ class RequestService {
 
   // General methods
   get numRequests() {
-    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests;
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests;
   }
   resetWallet() {
     this.#authRequestHandler.resetWallet();
     this.#substrateRequestHandler.resetWallet();
     this.#evmRequestHandler.resetWallet();
     this.#tonRequestHandler.resetWallet();
+    this.#cardanoRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
     this.#connectWCRequestHandler.resetWallet();
     this.#notSupportWCRequestHandler.resetWallet();

package/cjs/services/setting-service/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.DEFAULT_UNLOCK_TYPE = exports.DEFAULT_THEME = exports.DEFAULT_SHOW_ZERO_BALANCE = exports.DEFAULT_SHOW_BALANCE = exports.DEFAULT_SETTING = exports.DEFAULT_NOTIFICATION_TYPE = exports.DEFAULT_NOTIFICATION_SETUP = exports.DEFAULT_LANGUAGE = exports.DEFAULT_CURRENCY = exports.DEFAULT_CHAIN_PATROL_ENABLE = exports.DEFAULT_CAMERA_ENABLE = exports.DEFAULT_AUTO_LOCK_TIME = exports.DEFAULT_ALL_LOGO = exports.DEFAULT_ALLOW_ONE_SIGN = void 0;
+exports.DEFAULT_UNLOCK_TYPE = exports.DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS = exports.DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE = exports.DEFAULT_THEME = exports.DEFAULT_SHOW_ZERO_BALANCE = exports.DEFAULT_SHOW_BALANCE = exports.DEFAULT_SETTING = exports.DEFAULT_NOTIFICATION_TYPE = exports.DEFAULT_NOTIFICATION_SETUP = exports.DEFAULT_LANGUAGE = exports.DEFAULT_CURRENCY = exports.DEFAULT_CHAIN_PATROL_ENABLE = exports.DEFAULT_CAMERA_ENABLE = exports.DEFAULT_AUTO_LOCK_TIME = exports.DEFAULT_ALL_LOGO = exports.DEFAULT_ALLOW_ONE_SIGN = exports.DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS = void 0;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/utils");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -48,6 +48,12 @@ const DEFAULT_NOTIFICATION_SETUP = {
   }
 };
 exports.DEFAULT_NOTIFICATION_SETUP = DEFAULT_NOTIFICATION_SETUP;
+const DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS = false;
+exports.DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS = DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS;
+const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS = false;
+exports.DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS = DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS;
+const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE = false;
+exports.DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE = DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE;
 const DEFAULT_SETTING = {
   language: DEFAULT_LANGUAGE,
   currency: DEFAULT_CURRENCY,
@@ -61,6 +67,9 @@ const DEFAULT_SETTING = {
   timeAutoLock: DEFAULT_AUTO_LOCK_TIME,
   enableChainPatrol: DEFAULT_CHAIN_PATROL_ENABLE,
   notificationSetup: DEFAULT_NOTIFICATION_SETUP,
+  isAcknowledgedUnifiedAccountMigration: DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS,
+  isUnifiedAccountMigrationInProgress: DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS,
+  isUnifiedAccountMigrationDone: DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE,
   walletReference: '',
   allowOneSign: DEFAULT_ALLOW_ONE_SIGN
 };

package/cjs/services/storage-service/DatabaseService.js

@@ -607,6 +607,9 @@ class DatabaseService {
   removeAccountNotifications(proxyId) {
     return this.stores.inappNotification.removeAccountNotifications(proxyId);
   }
+  updateNotificationProxyId(proxyIds, newProxyId, newName) {
+    return this.stores.inappNotification.updateNotificationProxyId(proxyIds, newProxyId, newName);
+  }
   async exportDB() {
     const blob = await (0, _dexieExportImport.exportDB)(this._db, {
       filter: (table, value, key) => {

package/cjs/services/storage-service/db-stores/InappNotification.js

@@ -43,6 +43,12 @@ class InappNotificationStore extends _BaseStore.default {
     });
     return filteredTable.toArray();
   }
+  updateNotificationProxyId(proxyIds, newProxyId, newName) {
+    this.table.where('proxyId').anyOfIgnoreCase(proxyIds).modify(item => {
+      item.proxyId = newProxyId;
+      item.title = item.title.replace(/\[.*?\]/, `[${newName}]`);
+    }).catch(console.error);
+  }
   async cleanUpOldNotifications(overdueTime) {
     const currentTimestamp = Date.now();
     return this.table.filter(item => item.time <= currentTimestamp - overdueTime).delete();