@subwallet/extension-base 1.3.21-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/migration-service/scripts/databases/ClearMetadataDatabase.js

@@ -5,31 +5,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
-var _utils = require("@subwallet/extension-base/utils");
+var _ClearMetadataForChains = _interopRequireDefault(require("./ClearMetadataForChains"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-class ClearMetadataDatabase extends _Base.default {
-  async run() {
-    // Clear all old metadata data
-    await this.state.dbService.stores.metadata.clear();
-    const activeChains = this.state.chainService.getActiveChains();
-    const chainInfoMap = this.state.chainService.getChainInfoMap();
-    const reloadChains = activeChains.filter(chain => {
-      var _chainInfoMap$chain$s;
-      return !!((_chainInfoMap$chain$s = chainInfoMap[chain].substrateInfo) !== null && _chainInfoMap$chain$s !== void 0 && _chainInfoMap$chain$s.genesisHash);
-    });
-    for (const chain of reloadChains) {
-      const substrateApi = this.state.chainService.getSubstrateApi(chain);
-      const callback = substrateApi => {
-        (0, _utils.cacheMetadata)(chain, substrateApi, this.state.chainService);
-      };
-      Promise.race([substrateApi.isReady, (0, _utils.waitTimeout)(2000)]).finally(() => {
-        substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.connect(callback);
-      });
-    }
-    return Promise.resolve();
-  }
+class ClearMetadataDatabase extends _ClearMetadataForChains.default {
+  chains = [];
 }
 exports.default = ClearMetadataDatabase;

package/cjs/services/migration-service/scripts/databases/ClearMetadataForChains.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+var _utils = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ClearMetadataForChains extends _Base.default {
+  async run() {
+    const isClearAll = this.chains.length === 0;
+    if (isClearAll) {
+      // Clear all old metadata data
+      await this.state.dbService.stores.metadata.clear();
+    } else {
+      await this.state.dbService.stores.metadata.clearByChains(this.chains);
+    }
+    const activeChains = this.state.chainService.getActiveChains();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const reloadChains = activeChains.filter(chain => {
+      var _chainInfoMap$chain$s;
+      return !!((_chainInfoMap$chain$s = chainInfoMap[chain].substrateInfo) !== null && _chainInfoMap$chain$s !== void 0 && _chainInfoMap$chain$s.genesisHash) && (isClearAll || this.chains.includes(chain));
+    });
+    for (const chain of reloadChains) {
+      const substrateApi = this.state.chainService.getSubstrateApi(chain);
+      const callback = substrateApi => {
+        (0, _utils.cacheMetadata)(chain, substrateApi, this.state.chainService);
+      };
+      Promise.race([substrateApi.isReady, (0, _utils.waitTimeout)(2000)]).finally(() => {
+        substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.connect(callback);
+      });
+    }
+    return Promise.resolve();
+  }
+}
+exports.default = ClearMetadataForChains;

package/cjs/services/migration-service/scripts/databases/ClearMetadataForMythos.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ClearMetadataForChains = _interopRequireDefault(require("./ClearMetadataForChains"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ClearMetadataForMythos extends _ClearMetadataForChains.default {
+  chains = ['mythos', 'muse_testnet'];
+}
+exports.default = ClearMetadataForMythos;

package/cjs/services/migration-service/scripts/index.js

@@ -4,9 +4,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.EVERYTIME = void 0;
+exports.default = exports.MYTHOS_MIGRATION_KEY = exports.EVERYTIME = void 0;
 var _AutoEnableSomeTokens = _interopRequireDefault(require("./databases/AutoEnableSomeTokens"));
 var _ClearMetadataDatabase = _interopRequireDefault(require("./databases/ClearMetadataDatabase"));
+var _ClearMetadataForMythos = _interopRequireDefault(require("./databases/ClearMetadataForMythos"));
 var _MigrateAssetSetting = _interopRequireDefault(require("./databases/MigrateAssetSetting"));
 var _MigrateEarningVersion = _interopRequireDefault(require("./databases/MigrateEarningVersion"));
 var _ReloadMetadata = _interopRequireDefault(require("./databases/ReloadMetadata"));
@@ -39,6 +40,8 @@ var _MigrateWalletReference = _interopRequireDefault(require("./MigrateWalletRef
 
 const EVERYTIME = '__everytime__';
 exports.EVERYTIME = EVERYTIME;
+const MYTHOS_MIGRATION_KEY = '1.3.21-01';
+exports.MYTHOS_MIGRATION_KEY = MYTHOS_MIGRATION_KEY;
 var _default = {
   '1.0.1-11': _MigrateNetworkSettings.default,
   '1.0.1-20': _MigrateImportedToken.default,
@@ -69,7 +72,8 @@ var _default = {
   '1.2.13-01': _ReloadMetadata.default,
   '1.2.32-01': _MigratePairData.default,
   '1.3.6-01': _MigrateTransactionHistoryBridge.default,
-  '1.3.10-01': _ClearMetadataDatabase.default
+  '1.3.10-01': _ClearMetadataDatabase.default,
+  [MYTHOS_MIGRATION_KEY]: _ClearMetadataForMythos.default
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

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,