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

package/cjs/services/earning-service/handlers/native-staking/mythos.js

@@ -0,0 +1,337 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _basePara = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para"));
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class MythosNativeStakingPoolHandler extends _basePara.default {
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: false,
+    withdraw: true,
+    claimReward: true
+  };
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const nativeToken = this.nativeToken;
+    const defaultCallback = async () => {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      const poolInfo = await this.getPoolInfo();
+      !poolInfo && callback(data);
+    };
+    if (!this.isActive) {
+      await defaultCallback();
+      return () => {
+        cancel = true;
+      };
+    }
+    await defaultCallback();
+    await substrateApi.isReady;
+    const unsub = await substrateApi.api.query.collatorStaking.currentSession(async _session => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const currentSession = _session.toString();
+      const maxStakers = substrateApi.api.consts.collatorStaking.maxStakers.toString();
+      const unstakeDelay = substrateApi.api.consts.collatorStaking.stakeUnlockDelay.toString();
+      const maxStakedCandidates = substrateApi.api.consts.collatorStaking.maxStakedCandidates.toString();
+      const sessionTime = _constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default; // in hours
+      const blockTime = _constants._EXPECTED_BLOCK_TIME[this.chain];
+      const unstakingPeriod = parseInt(unstakeDelay) * blockTime / 60 / 60;
+      const _minStake = await substrateApi.api.query.collatorStaking.minStake();
+      const minStake = _minStake.toString();
+      const minStakeToHuman = (0, _utils2.formatNumber)(minStake, nativeToken.decimals || 0, _utils2.balanceFormatter);
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minStakeToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: parseInt(maxStakedCandidates),
+          maxWithdrawalRequestPerFarmer: 3,
+          earningThreshold: {
+            join: minStake,
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          era: parseInt(currentSession),
+          eraTime: sessionTime,
+          unstakingPeriod: unstakingPeriod,
+          totalApy: undefined
+          // tvl: totalStake.toString(),
+          // inflation
+        },
+
+        maxPoolMembers: parseInt(maxStakers)
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const unsub = await substrateApi.api.query.collatorStaking.userStake.multi(useAddresses, async userStakes => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (userStakes) {
+        await Promise.all(userStakes.map(async (_userStake, i) => {
+          const userStake = _userStake.toPrimitive();
+          const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+          if (userStake) {
+            const nominatorMetadata = await this.parseCollatorMetadata(this.chainInfo, useAddresses[i], substrateApi, userStake);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: _types.EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+  async parseCollatorMetadata(chainInfo, stakerAddress, substrateApi, userStake) {
+    const nominationList = [];
+    const unstakingList = [];
+    let unstakingBalance = BigInt(0);
+    const {
+      candidates,
+      stake
+    } = userStake;
+    const [_minStake, _unstaking, _currentBlock, _currentTimestamp] = await Promise.all([substrateApi.api.query.collatorStaking.minStake(), substrateApi.api.query.collatorStaking.releaseQueues(stakerAddress), substrateApi.api.query.system.number(), substrateApi.api.query.timestamp.now()]);
+    const minStake = _minStake.toPrimitive();
+    const stakingStatus = candidates && !!candidates.length ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING;
+    const isBondedBefore = candidates && !!candidates.length;
+    const unstakings = _unstaking.toPrimitive();
+    const currentBlock = _currentBlock.toPrimitive();
+    const currentTimestamp = _currentTimestamp.toPrimitive();
+    const blockDuration = _constants._EXPECTED_BLOCK_TIME[chainInfo.slug];
+    if (candidates.length) {
+      await Promise.all(candidates.map(async collatorAddress => {
+        const _stakeInfo = await substrateApi.api.query.collatorStaking.candidateStake(collatorAddress, stakerAddress);
+        const stakeInfo = _stakeInfo.toPrimitive();
+        const activeStake = stakeInfo.stake.toString();
+        const earningStatus = BigInt(activeStake) > BigInt(0) && BigInt(activeStake) >= BigInt(minStake) ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING;
+        nominationList.push({
+          status: earningStatus,
+          chain: chainInfo.slug,
+          validatorAddress: collatorAddress,
+          activeStake,
+          validatorMinStake: minStake,
+          hasUnstaking: !!unstakings.length
+        });
+      }));
+    }
+    if (unstakings.length) {
+      unstakings.forEach(unstaking => {
+        const releaseBlock = unstaking.block;
+        const unstakeAmount = unstaking.amount;
+        const isClaimable = currentBlock >= releaseBlock;
+        const targetTimestampMs = (releaseBlock - currentBlock) * blockDuration * 1000 + currentTimestamp;
+        unstakingBalance = unstakingBalance + BigInt(unstakeAmount);
+        unstakingList.push({
+          chain: chainInfo.slug,
+          status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+          claimable: unstakeAmount,
+          targetTimestampMs
+        });
+      });
+    }
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: (BigInt(stake) + unstakingBalance).toString(),
+      activeStake: stake,
+      unstakeBalance: unstakingBalance.toString() || '0',
+      isBondedBefore: isBondedBefore,
+      nominations: nominationList,
+      unstakings: unstakingList
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const substrateApi = await this.substrateApi.isReady;
+    const [_allCollators, _minStake, _commission] = await Promise.all([substrateApi.api.query.collatorStaking.candidates.entries(), substrateApi.api.query.collatorStaking.minStake(), substrateApi.api.query.collatorStaking.collatorRewardPercentage()]);
+    const maxStakersPerCollator = substrateApi.api.consts.collatorStaking.maxStakers.toPrimitive();
+    return _allCollators.map(_collator => {
+      const _collatorAddress = _collator[0].toHuman();
+      const collatorAddress = _collatorAddress[0];
+      const collatorInfo = _collator[1].toPrimitive();
+      const bnTotalStake = BigInt(collatorInfo.stake);
+      const numOfStakers = parseInt(collatorInfo.stakers);
+      const isCrowded = numOfStakers >= maxStakersPerCollator;
+      return {
+        address: collatorAddress,
+        chain: this.chain,
+        totalStake: bnTotalStake.toString(),
+        ownStake: '0',
+        otherStake: bnTotalStake.toString(),
+        minBond: _minStake.toPrimitive(),
+        nominatorCount: numOfStakers,
+        commission: (0, _utils.getCommission)(_commission.toString()),
+        blocked: false,
+        isVerified: false,
+        isCrowded
+      };
+    });
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    var _substrateApi$api$cal, _substrateApi$api$cal2;
+    const substrateApi = await this.substrateApi.isReady;
+    const {
+      address,
+      amount,
+      selectedValidators
+    } = data;
+    const selectedValidatorInfo = selectedValidators[0];
+    const _hasReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.collatorStakingApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.shouldClaim(address));
+    const hasReward = _hasReward === null || _hasReward === void 0 ? void 0 : _hasReward.toPrimitive();
+    const extrinsicList = [];
+    if (positionInfo !== null && positionInfo !== void 0 && positionInfo.isBondedBefore && hasReward) {
+      extrinsicList.push(substrateApi.api.tx.collatorStaking.claimRewards());
+    }
+    extrinsicList.push(...[substrateApi.api.tx.collatorStaking.lock(amount), substrateApi.api.tx.collatorStaking.stake([{
+      candidate: selectedValidatorInfo.address,
+      stake: amount
+    }])]);
+    return [substrateApi.api.tx.utility.batchAll(extrinsicList), {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    var _substrateApi$api$cal3, _substrateApi$api$cal4;
+    const substrateApi = await this.substrateApi.isReady;
+    const _hasReward = await ((_substrateApi$api$cal3 = substrateApi.api.call) === null || _substrateApi$api$cal3 === void 0 ? void 0 : (_substrateApi$api$cal4 = _substrateApi$api$cal3.collatorStakingApi) === null || _substrateApi$api$cal4 === void 0 ? void 0 : _substrateApi$api$cal4.shouldClaim(address));
+    const hasReward = _hasReward === null || _hasReward === void 0 ? void 0 : _hasReward.toPrimitive();
+    const extrinsicList = [];
+    if (hasReward) {
+      extrinsicList.push(substrateApi.api.tx.collatorStaking.claimRewards());
+    }
+    extrinsicList.push(...[substrateApi.api.tx.collatorStaking.unstakeFrom(selectedTarget), substrateApi.api.tx.collatorStaking.unlock(null) // ignore amount to unlock all
+    ]);
+
+    return [_KoniTypes.ExtrinsicType.STAKING_UNBOND, substrateApi.api.tx.utility.batchAll(extrinsicList)];
+  }
+
+  /* Leave pool action */
+
+  /* Get pool reward */
+  async getPoolReward(useAddresses, callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    if (substrateApi.api.call.collatorStakingApi) {
+      await Promise.all(useAddresses.map(async address => {
+        if (!cancel) {
+          const _unclaimedReward = await substrateApi.api.call.collatorStakingApi.totalRewards(address);
+          const earningRewardItem = {
+            ...this.baseInfo,
+            address: address,
+            type: this.type,
+            unclaimedReward: (_unclaimedReward === null || _unclaimedReward === void 0 ? void 0 : _unclaimedReward.toString()) || '0',
+            state: _KoniTypes.APIItemState.READY
+          };
+          if (_unclaimedReward.toString() !== '0') {
+            await this.createClaimNotification(earningRewardItem, this.nativeToken);
+          }
+          callback(earningRewardItem);
+        }
+      }));
+    }
+    return () => {
+      cancel = false;
+    };
+  }
+  /* Get pool reward */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake() {
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const substrateApi = await this.substrateApi.isReady;
+    return substrateApi.api.tx.collatorStaking.release();
+  }
+  async handleYieldClaimReward(address, bondReward) {
+    const substrateApi = await this.substrateApi.isReady;
+    return substrateApi.api.tx.collatorStaking.claimRewards();
+  }
+  /* Other action */
+}
+exports.default = MythosNativeStakingPoolHandler;

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

@@ -12,6 +12,7 @@ var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
 var _base = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base"));
+var _mythos = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/native-staking/mythos"));
 var _types2 = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _fetchStaticCache = require("@subwallet/extension-base/utils/fetchStaticCache");
@@ -75,6 +76,9 @@ class EarningService {
       if (_constants2._STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
         handlers.push(new _handlers.TaoNativeStakingPoolHandler(this.state, chain));
       }
+      if (_constants2._STAKING_CHAIN_GROUP.mythos.includes(chain)) {
+        handlers.push(new _mythos.default(this.state, chain));
+      }
       if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
       }
@@ -383,10 +387,8 @@ class EarningService {
   async subscribePoolPositions(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const {
-      evm: evmAddresses,
-      substrate: substrateAddresses
-    } = (0, _utils2.categoryAddresses)(addresses);
+    const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+    const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
@@ -532,10 +534,8 @@ class EarningService {
   async getPoolReward(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const {
-      evm: evmAddresses,
-      substrate: substrateAddresses
-    } = (0, _utils2.categoryAddresses)(addresses);
+    const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+    const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
@@ -590,10 +590,8 @@ class EarningService {
   async fetchPoolRewardHistory(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const {
-      evm: evmAddresses,
-      substrate: substrateAddresses
-    } = (0, _utils2.categoryAddresses)(addresses);
+    const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+    const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {

package/cjs/services/earning-service/utils/index.js

@@ -118,6 +118,8 @@ function isActionFromValidator(stakingType, chain) {
     return true;
   } else if (_constants._STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
     return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.mythos.includes(chain)) {
+    return true;
   }
   return false;
 }

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/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) {