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

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/migration-service/scripts/databases/ClearMetadataDatabase.d.ts

@@ -1,4 +1,4 @@
-import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
-export default class ClearMetadataDatabase extends BaseMigrationJob {
-    run(): Promise<void>;
+import ClearMetadataForChains from './ClearMetadataForChains';
+export default class ClearMetadataDatabase extends ClearMetadataForChains {
+    chains: string[];
 }

package/services/migration-service/scripts/databases/ClearMetadataDatabase.js

@@ -1,27 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
-import { cacheMetadata, waitTimeout } from '@subwallet/extension-base/utils';
-export default class ClearMetadataDatabase extends BaseMigrationJob {
-  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 => {
-        cacheMetadata(chain, substrateApi, this.state.chainService);
-      };
-      Promise.race([substrateApi.isReady, waitTimeout(2000)]).finally(() => {
-        substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.connect(callback);
-      });
-    }
-    return Promise.resolve();
-  }
+import ClearMetadataForChains from "./ClearMetadataForChains.js";
+export default class ClearMetadataDatabase extends ClearMetadataForChains {
+  chains = [];
 }

package/services/migration-service/scripts/databases/ClearMetadataForChains.d.ts

@@ -0,0 +1,5 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default abstract class ClearMetadataForChains extends BaseMigrationJob {
+    protected abstract chains: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,32 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import { cacheMetadata, waitTimeout } from '@subwallet/extension-base/utils';
+export default class ClearMetadataForChains extends BaseMigrationJob {
+  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 => {
+        cacheMetadata(chain, substrateApi, this.state.chainService);
+      };
+      Promise.race([substrateApi.isReady, waitTimeout(2000)]).finally(() => {
+        substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.connect(callback);
+      });
+    }
+    return Promise.resolve();
+  }
+}

package/services/migration-service/scripts/databases/ClearMetadataForMythos.d.ts

@@ -0,0 +1,4 @@
+import ClearMetadataForChains from './ClearMetadataForChains';
+export default class ClearMetadataForMythos extends ClearMetadataForChains {
+    chains: string[];
+}

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

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import ClearMetadataForChains from "./ClearMetadataForChains.js";
+export default class ClearMetadataForMythos extends ClearMetadataForChains {
+  chains = ['mythos', 'muse_testnet'];
+}

package/services/migration-service/scripts/index.d.ts

@@ -1,4 +1,5 @@
 import BaseMigrationJob from '../Base';
 export declare const EVERYTIME = "__everytime__";
+export declare const MYTHOS_MIGRATION_KEY = "1.3.21-01";
 declare const _default: Record<string, typeof BaseMigrationJob>;
 export default _default;

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

@@ -3,6 +3,7 @@
 
 import AutoEnableSomeTokens from "./databases/AutoEnableSomeTokens.js";
 import ClearMetadataDatabase from "./databases/ClearMetadataDatabase.js";
+import ClearMetadataForMythos from "./databases/ClearMetadataForMythos.js";
 import MigrateAssetSetting from "./databases/MigrateAssetSetting.js";
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import ReloadMetadata from "./databases/ReloadMetadata.js";
@@ -31,6 +32,7 @@ import MigrateTransactionHistoryBridge from "./MigrateTransactionHistoryBridge.j
 import MigrateTransactionHistoryBySymbol from "./MigrateTransactionHistoryBySymbol.js";
 import MigrateWalletReference from "./MigrateWalletReference.js";
 export const EVERYTIME = '__everytime__';
+export const MYTHOS_MIGRATION_KEY = '1.3.21-01';
 export default {
   '1.0.1-11': MigrateNetworkSettings,
   '1.0.1-20': MigrateImportedToken,
@@ -61,7 +63,8 @@ export default {
   '1.2.13-01': ReloadMetadata,
   '1.2.32-01': MigratePairData,
   '1.3.6-01': MigrateTransactionHistoryBridge,
-  '1.3.10-01': ClearMetadataDatabase
+  '1.3.10-01': ClearMetadataDatabase,
+  [MYTHOS_MIGRATION_KEY]: ClearMetadataForMythos
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

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;
+}