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

package/types/account/info/keyring.js

@@ -65,7 +65,16 @@ export let AccountChainType;
   AccountChainType["ETHEREUM"] = "ethereum";
   AccountChainType["BITCOIN"] = "bitcoin";
   AccountChainType["TON"] = "ton";
+  AccountChainType["CARDANO"] = "cardano";
 })(AccountChainType || (AccountChainType = {}));
+export const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
+  [AccountChainType.SUBSTRATE]: 1,
+  [AccountChainType.ETHEREUM]: 2,
+  [AccountChainType.TON]: 3,
+  [AccountChainType.CARDANO]: 4,
+  [AccountChainType.BITCOIN]: 5
+};
+export const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
 export let AccountActions;
 
 /**

package/types/account/info/proxy.d.ts

@@ -15,6 +15,7 @@ export interface AccountProxyData {
     name: string;
     parentId?: string;
     suri?: string;
+    isMigrationDone?: boolean;
 }
 /**
  * Represents a mapping of unique identifiers to account proxy data.
@@ -55,6 +56,7 @@ export interface AccountProxy extends AccountProxyData {
     children?: string[];
     tokenTypes: _AssetType[];
     accountActions: AccountActions[];
+    isNeedMigrateUnifiedAccount?: boolean;
 }
 export declare type AccountProxyMap = Record<string, AccountProxy>;
 export interface AccountProxyExtra extends AccountProxy {

package/types/balance/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _BalanceMetadata, APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BN } from '@polkadot/util';
 export interface TokenBalanceRaw {
     reserved: BN;
@@ -52,3 +52,6 @@ export interface SubscribeEvmPalletBalance extends SubscribeBasePalletBalance {
 export interface SubscribeTonPalletBalance extends SubscribeBasePalletBalance {
     tonApi: _TonApi;
 }
+export interface SusbcribeCardanoPalletBalance extends SubscribeBasePalletBalance {
+    cardanoApi: _CardanoApi;
+}

package/types/fee/base.d.ts

@@ -1,4 +1,4 @@
-export declare type FeeChainType = 'evm' | 'substrate' | 'ton';
+export declare type FeeChainType = 'evm' | 'substrate' | 'ton' | 'cardano';
 export interface BaseFeeInfo {
     busyNetwork: boolean;
     type: FeeChainType;

package/types/fee/cardano.d.ts

@@ -0,0 +1,18 @@
+import { BaseFeeDetail, BaseFeeInfo } from './base';
+import { FeeDefaultOption } from './option';
+/** @deprecated */
+export interface CardanoTipInfo {
+    tip: string;
+}
+/** @deprecated */
+export interface CardanoFeeInfo extends BaseFeeInfo {
+    type: 'ton';
+    options: {
+        slow: CardanoTipInfo;
+        average: CardanoTipInfo;
+        fast: CardanoTipInfo;
+        default: FeeDefaultOption;
+    };
+}
+/** @deprecated */
+export declare type CardanoFeeDetail = CardanoFeeInfo & BaseFeeDetail;

package/types/fee/cardano.js

@@ -0,0 +1 @@
+export {};

package/types/fee/subscription.d.ts

@@ -1,10 +1,11 @@
 import { BehaviorSubject } from 'rxjs';
+import { CardanoFeeDetail, CardanoFeeInfo, CardanoTipInfo } from './cardano';
 import { EvmEIP1559FeeOption, EvmFeeDetail, EvmFeeInfo } from './evm';
 import { SubstrateFeeDetail, SubstrateFeeInfo, SubstrateTipInfo } from './substrate';
 import { TonFeeDetail, TonFeeInfo, TonTipInfo } from './ton';
-export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo;
-export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail;
-export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo;
+export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo | CardanoFeeInfo;
+export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail | CardanoFeeDetail;
+export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo | CardanoTipInfo;
 export interface FeeSubscription {
     observer: BehaviorSubject<FeeInfo | undefined>;
     subscription: Record<string, VoidFunction>;

package/types/swap/index.d.ts

@@ -1,7 +1,7 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
+import { BaseStepDetail, BaseStepType, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import BigN from 'bignumber.js';
 import { BaseProcessRequestSign, TransactionData } from '../transaction';
 export declare type SwapRate = number;
@@ -44,7 +44,8 @@ export declare enum SwapErrorType {
     NOT_MEET_MIN_EXPECTED = "NOT_MEET_MIN_EXPECTED"
 }
 export declare enum SwapStepType {
-    SWAP = "SWAP"
+    SWAP = "SWAP",
+    PERMIT = "PERMIT"
 }
 export declare enum SwapProviderId {
     CHAIN_FLIP_TESTNET = "CHAIN_FLIP_TESTNET",
@@ -55,7 +56,8 @@ export declare enum SwapProviderId {
     KUSAMA_ASSET_HUB = "KUSAMA_ASSET_HUB",
     ROCOCO_ASSET_HUB = "ROCOCO_ASSET_HUB",
     WESTEND_ASSET_HUB = "WESTEND_ASSET_HUB",
-    SIMPLE_SWAP = "SIMPLE_SWAP"
+    SIMPLE_SWAP = "SIMPLE_SWAP",
+    UNISWAP = "UNISWAP"
 }
 export declare const _SUPPORTED_SWAP_PROVIDERS: SwapProviderId[];
 export interface SwapProvider {
@@ -139,6 +141,7 @@ export interface SwapSubmitParams extends BaseProcessRequestSign {
     address: string;
     slippage: number;
     recipient?: string;
+    cacheProcessId: string;
 }
 export interface SwapSubmitStepData {
     txChain: string;
@@ -147,6 +150,7 @@ export interface SwapSubmitStepData {
     transferNativeAmount: string;
     extrinsicType: ExtrinsicType;
     chainType: ChainType;
+    isPermit?: boolean;
 }
 export interface OptimalSwapPathParams {
     request: SwapRequest;
@@ -169,5 +173,9 @@ export interface SlippageType {
     slippage: BigN;
     isCustomType: boolean;
 }
+export interface PermitSwapData {
+    processId: string;
+    step: BaseStepType;
+}
 export declare const CHAINFLIP_SLIPPAGE = 0.02;
 export declare const SIMPLE_SWAP_SLIPPAGE = 0.05;

package/types/swap/index.js

@@ -21,6 +21,7 @@ export let SwapErrorType;
 export let SwapStepType;
 (function (SwapStepType) {
   SwapStepType["SWAP"] = "SWAP";
+  SwapStepType["PERMIT"] = "PERMIT";
 })(SwapStepType || (SwapStepType = {}));
 export let SwapProviderId;
 (function (SwapProviderId) {
@@ -33,10 +34,14 @@ export let SwapProviderId;
   SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
   SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
+  SwapProviderId["UNISWAP"] = "UNISWAP";
 })(SwapProviderId || (SwapProviderId = {}));
-export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB,
+export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET,
+// SwapProviderId.HYDRADX_TESTNET,
+SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB,
+// SwapProviderId.ROCOCO_ASSET_HUB,
 // SwapProviderId.WESTEND_ASSET_HUB,
-SwapProviderId.SIMPLE_SWAP];
+SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP];
 // process handling
 export let SwapFeeType;
 (function (SwapFeeType) {

package/utils/account/analyze.js

@@ -15,7 +15,8 @@ const isStrValidWithAddress = (str, account, chainInfo) => {
     } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
       return 'valid';
     }
-  } else if (account.chainType === AccountChainType.TON) {
+  } else if (account.chainType === AccountChainType.TON || account.chainType === AccountChainType.CARDANO) {
+    // todo: recheck for Cardano
     const isTestnet = chainInfo.isTestnet;
     const reformated = reformatAddress(account.address, isTestnet ? 0 : 1);
     if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {

package/utils/account/common.d.ts

@@ -1,16 +1,21 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountChainType } from '@subwallet/extension-base/types';
 import { KeypairType } from '@subwallet/keyring/types';
 export declare function isAccountAll(address?: string): boolean;
 export declare function reformatAddress(address: string, networkPrefix?: number, isEthereum?: boolean): string;
 export declare const _reformatAddressWithChain: (address: string, chainInfo: _ChainInfo) => string;
 export declare const getAccountChainTypeForAddress: (address: string) => AccountChainType;
-export declare function categoryAddresses(addresses: string[]): {
-    substrate: string[];
-    evm: string[];
-    ton: string[];
-    bitcoin: string[];
-};
+interface AddressesByChainType {
+    [ChainType.SUBSTRATE]: string[];
+    [ChainType.EVM]: string[];
+    [ChainType.BITCOIN]: string[];
+    [ChainType.TON]: string[];
+    [ChainType.CARDANO]: string[];
+}
+export declare function getAddressesByChainType(addresses: string[], chainTypes: ChainType[]): string[];
+export declare function getAddressesByChainTypeMap(addresses: string[]): AddressesByChainType;
 export declare function quickFormatAddressToCompare(address?: string): string | undefined;
 /** @deprecated */
 export declare const modifyAccountName: (type: KeypairType, name: string, modify: boolean) => string;
+export {};

package/utils/account/common.js

@@ -1,11 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType } from '@subwallet/extension-base/types';
-import { getAccountChainType } from '@subwallet/extension-base/utils';
-import { decodeAddress, encodeAddress, getKeypairTypeByAddress, isAddress, isBitcoinAddress, isTonAddress } from '@subwallet/keyring';
+import { getAccountChainTypeFromKeypairType } from '@subwallet/extension-base/utils';
+import { decodeAddress, encodeAddress, getKeypairTypeByAddress, isAddress, isBitcoinAddress, isCardanoAddress, isTonAddress } from '@subwallet/keyring';
 import { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
 export function isAccountAll(address) {
   return address === ALL_ACCOUNT_KEY;
@@ -36,10 +37,11 @@ export function reformatAddress(address, networkPrefix = 42, isEthereum = false)
   }
 }
 export const _reformatAddressWithChain = (address, chainInfo) => {
+  // todo: check for cardano
   const chainType = _chainInfoToChainType(chainInfo);
   if (chainType === AccountChainType.SUBSTRATE) {
     return reformatAddress(address, _getChainSubstrateAddressPrefix(chainInfo));
-  } else if (chainType === AccountChainType.TON) {
+  } else if (chainType === AccountChainType.TON || chainType === AccountChainType.CARDANO) {
     const isTestnet = chainInfo.isTestnet;
     return reformatAddress(address, isTestnet ? 0 : 1);
   } else {
@@ -48,30 +50,37 @@ export const _reformatAddressWithChain = (address, chainInfo) => {
 };
 export const getAccountChainTypeForAddress = address => {
   const type = getKeypairTypeByAddress(address);
-  return getAccountChainType(type);
+  return getAccountChainTypeFromKeypairType(type);
 };
-export function categoryAddresses(addresses) {
-  const substrate = [];
-  const evm = [];
-  const ton = [];
-  const bitcoin = [];
+export function getAddressesByChainType(addresses, chainTypes) {
+  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses);
+  return chainTypes.map(chainType => {
+    return addressByChainTypeMap[chainType];
+  }).flat(); // todo: recheck
+}
+
+export function getAddressesByChainTypeMap(addresses) {
+  const addressByChainType = {
+    substrate: [],
+    evm: [],
+    bitcoin: [],
+    ton: [],
+    cardano: []
+  };
   addresses.forEach(address => {
     if (isEthereumAddress(address)) {
-      evm.push(address);
+      addressByChainType.evm.push(address);
     } else if (isTonAddress(address)) {
-      ton.push(address);
+      addressByChainType.ton.push(address);
     } else if (isBitcoinAddress(address)) {
-      bitcoin.push(address);
+      addressByChainType.bitcoin.push(address);
+    } else if (isCardanoAddress(address)) {
+      addressByChainType.cardano.push(address);
     } else {
-      substrate.push(address);
+      addressByChainType.substrate.push(address);
     }
   });
-  return {
-    bitcoin,
-    evm,
-    substrate,
-    ton
-  };
+  return addressByChainType;
 }
 export function quickFormatAddressToCompare(address) {
   if (!isAddress(address)) {

package/utils/account/derive/info/solo.js

@@ -6,7 +6,7 @@ import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/
 import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert } from '@polkadot/util';
-import { validateEvmDerivationPath, validateOtherSubstrateDerivationPath, validateSr25519DerivationPath, validateTonDerivationPath, validateUnifiedDerivationPath } from "../validate.js";
+import { validateCardanoDerivationPath, validateEvmDerivationPath, validateOtherSubstrateDerivationPath, validateSr25519DerivationPath, validateTonDerivationPath, validateUnifiedDerivationPath } from "../validate.js";
 export const parseUnifiedSuriToDerivationPath = (suri, type) => {
   const reg = /^\/\/(\d+)(\/\/\d+)?$/;
   if (suri.match(reg)) {
@@ -18,12 +18,16 @@ export const parseUnifiedSuriToDerivationPath = (suri, type) => {
         return `m/44'/60'/0'/0/${first}/${secondIndex}`;
       } else if (type === 'ton') {
         return `m/44'/607'/${first}'/${secondIndex}'`;
+      } else if (type === 'cardano') {
+        return `m/1852'/1815'/${first}'/${secondIndex}'`;
       }
     } else {
       if (type === 'ethereum') {
         return `m/44'/60'/0'/0/${first}`;
       } else if (type === 'ton') {
         return `m/44'/607'/${first}'`;
+      } else if (type === 'cardano') {
+        return `m/1852'/1815'/${first}'`;
       }
     }
     if (SubstrateKeypairTypes.includes(type)) {
@@ -40,7 +44,7 @@ export const getSoloDerivationInfo = (type, metadata = {}) => {
   } = metadata;
   if (suri) {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : () => undefined;
+      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : type === 'cardano' ? validateCardanoDerivationPath : () => undefined;
       const validateTypeRs = validateTypeFunc(derivePath);
       if (validateTypeRs) {
         return {
@@ -97,7 +101,7 @@ export const getSoloDerivationInfo = (type, metadata = {}) => {
     }
   } else {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : () => undefined;
+      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : type === 'cardano' ? validateCardanoDerivationPath : () => undefined;
       const validateTypeRs = validateTypeFunc(derivePath);
       if (validateTypeRs) {
         return {
@@ -210,6 +214,7 @@ export const derivePair = (parentPair, name, suri, derivationPath) => {
   }
   const isEvm = EthereumKeypairTypes.includes(parentPair.type);
   const isTon = parentPair.type === 'ton';
+  const isCardano = parentPair.type === 'cardano';
   const meta = {
     name,
     parentAddress: parentPair.address,
@@ -220,8 +225,8 @@ export const derivePair = (parentPair, name, suri, derivationPath) => {
   if (isTon && (_parentPair$ton = parentPair.ton) !== null && _parentPair$ton !== void 0 && _parentPair$ton.contractVersion) {
     meta.tonContractVersion = parentPair.ton.contractVersion;
   }
-  if (derivationPath && (isEvm || isTon)) {
-    return isEvm ? parentPair.evm.deriveCustom(derivationPath, meta) : parentPair.ton.deriveCustom(derivationPath, meta);
+  if (derivationPath && (isEvm || isTon || isCardano)) {
+    return isEvm ? parentPair.evm.deriveCustom(derivationPath, meta) : isTon ? parentPair.ton.deriveCustom(derivationPath, meta) : parentPair.cardano.deriveCustom(derivationPath, meta);
   } else {
     return parentPair.substrate.derive(suri, meta);
   }

package/utils/account/derive/validate.d.ts

@@ -3,6 +3,7 @@ import { KeypairType, SubstrateKeypairType } from '@subwallet/keyring/types';
 export declare const validateUnifiedDerivationPath: (raw: string) => DerivePathInfo | undefined;
 export declare const validateEvmDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateTonDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
+export declare const validateCardanoDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateSr25519DerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateOtherSubstrateDerivationPath: (raw: string, type: Exclude<SubstrateKeypairType, 'sr25519'>) => IDerivePathInfo_ | undefined;
 export declare const validateDerivationPath: (raw: string, type?: KeypairType) => DerivePathInfo | undefined;

package/utils/account/derive/validate.js

@@ -96,6 +96,37 @@ export const validateTonDerivationPath = raw => {
     return undefined;
   }
 };
+export const validateCardanoDerivationPath = raw => {
+  const reg = /^m\/1852'\/1815'\/(\d+)'(\/\d+')?$/;
+  if (raw.match(reg)) {
+    const [, firstIndex, secondData] = raw.match(reg);
+    const first = parseInt(firstIndex, 10);
+    const autoIndexes = [first];
+    let depth;
+    let suri = `//${first}`;
+    if (first === 0) {
+      depth = 0;
+    } else {
+      depth = 1;
+    }
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/(\d+)/);
+      const second = parseInt(secondIndex, 10);
+      autoIndexes.push(second);
+      depth = 2;
+      suri += `//${second}`;
+    }
+    return {
+      depth,
+      type: 'cardano',
+      suri,
+      derivationPath: raw,
+      autoIndexes
+    };
+  } else {
+    return undefined;
+  }
+};
 export const validateSr25519DerivationPath = raw => {
   const reg = /\/(\/?)([^/]+)/g;
   const parts = raw.match(reg);
@@ -156,10 +187,12 @@ export const validateDerivationPath = (raw, type) => {
       return validateSr25519DerivationPath(raw);
     } else if (type === 'ed25519' || type === 'ecdsa') {
       return validateOtherSubstrateDerivationPath(raw, type);
+    } else if (type === 'cardano') {
+      return validateCardanoDerivationPath(raw);
     } else {
       return undefined;
     }
   } else {
-    return validateUnifiedDerivationPath(raw) || validateEvmDerivationPath(raw) || validateTonDerivationPath(raw) || validateSr25519DerivationPath(raw);
+    return validateUnifiedDerivationPath(raw) || validateEvmDerivationPath(raw) || validateTonDerivationPath(raw) || validateSr25519DerivationPath(raw) || validateCardanoDerivationPath(raw);
   }
 };

package/utils/account/transform.d.ts

@@ -4,7 +4,8 @@ import { AccountActions, AccountChainType, AccountJson, AccountProxy, AccountPro
 import { KeypairType, KeyringPair, KeyringPair$Meta } from '@subwallet/keyring/types';
 import { SingleAddress, SubjectInfo } from '@subwallet/ui-keyring/observable/types';
 export declare const createAccountProxyId: (_suri: string, derivationPath?: string) => `0x${string}`;
-export declare const getAccountChainType: (type: KeypairType) => AccountChainType;
+export declare const getAccountChainTypeFromKeypairType: (type: KeypairType) => AccountChainType;
+export declare const getDefaultKeypairTypeFromAccountChainType: (type: AccountChainType) => KeypairType;
 export declare const getAccountSignMode: (address: string, _meta?: KeyringPair$Meta) => AccountSignMode;
 export declare const getAccountActions: (signMode: AccountSignMode, networkType: AccountChainType, type: KeypairType, _meta?: KeyringPair$Meta, parentAccount?: AccountJson) => AccountActions[];
 export declare const getAccountTransactionActions: (signMode: AccountSignMode, networkType: AccountChainType, type?: KeypairType, _meta?: KeyringPair$Meta, _specialNetwork?: string) => ExtrinsicType[];

package/utils/account/transform.js

@@ -5,9 +5,9 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY, isProductionMode } from '@subwallet/extension-base/constants';
 import { _getSubstrateGenesisHash } from '@subwallet/extension-base/services/chain-service/utils';
-import { AccountActions, AccountChainType, AccountProxyType, AccountSignMode } from '@subwallet/extension-base/types';
+import { AccountActions, AccountChainType, AccountProxyType, AccountSignMode, SUPPORTED_ACCOUNT_CHAIN_TYPES } from '@subwallet/extension-base/types';
 import { getKeypairTypeByAddress, tonMnemonicToEntropy } from '@subwallet/keyring';
-import { BitcoinKeypairTypes, EthereumKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import { tonMnemonicValidate } from '@subwallet/keyring/utils';
 import { hexStripPrefix, u8aToHex } from '@polkadot/util';
 import { blake2AsHex, mnemonicToEntropy, mnemonicValidate } from '@polkadot/util-crypto';
@@ -32,8 +32,21 @@ export const createAccountProxyId = (_suri, derivationPath) => {
   }
   return blake2AsHex(data, 256);
 };
-export const getAccountChainType = type => {
-  return type ? EthereumKeypairTypes.includes(type) ? AccountChainType.ETHEREUM : TonKeypairTypes.includes(type) ? AccountChainType.TON : BitcoinKeypairTypes.includes(type) ? AccountChainType.BITCOIN : AccountChainType.SUBSTRATE : AccountChainType.SUBSTRATE;
+export const getAccountChainTypeFromKeypairType = type => {
+  return type ? EthereumKeypairTypes.includes(type) ? AccountChainType.ETHEREUM : TonKeypairTypes.includes(type) ? AccountChainType.TON : BitcoinKeypairTypes.includes(type) ? AccountChainType.BITCOIN : CardanoKeypairTypes.includes(type) ? AccountChainType.CARDANO : AccountChainType.SUBSTRATE : AccountChainType.SUBSTRATE;
+};
+export const getDefaultKeypairTypeFromAccountChainType = type => {
+  if (type === AccountChainType.ETHEREUM) {
+    return 'ethereum';
+  } else if (type === AccountChainType.TON) {
+    return 'ton';
+  } else if (type === AccountChainType.BITCOIN) {
+    return 'bitcoin-84';
+  } else if (type === AccountChainType.CARDANO) {
+    return 'cardano';
+  } else {
+    return 'sr25519';
+  }
 };
 export const getAccountSignMode = (address, _meta) => {
   const meta = _meta;
@@ -68,6 +81,7 @@ export const getAccountActions = (signMode, networkType, type, _meta, parentAcco
   const result = [];
   const meta = _meta;
 
+  // todo: check this function for Cardano
   // JSON
   if (signMode === AccountSignMode.PASSWORD) {
     result.push(AccountActions.EXPORT_JSON);
@@ -146,6 +160,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...EVM_ACTIONS];
       case AccountChainType.TON:
         return [...BASE_TRANSFER_ACTIONS];
+      case AccountChainType.CARDANO:
+        return [...BASE_TRANSFER_ACTIONS];
     }
   } else if (signMode === AccountSignMode.QR) {
     switch (networkType) {
@@ -155,6 +171,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         return [...(isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
       case AccountChainType.TON:
         return [];
+      case AccountChainType.CARDANO:
+        return [];
     }
   } else if (signMode === AccountSignMode.GENERIC_LEDGER) {
     switch (networkType) {
@@ -170,6 +188,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         ExtrinsicType.SEND_NFT, ExtrinsicType.SWAP];
       case AccountChainType.TON:
         return [...BASE_TRANSFER_ACTIONS];
+      case AccountChainType.CARDANO:
+        return [];
     }
   } else if (signMode === AccountSignMode.LEGACY_LEDGER) {
     // Only for Substrate
@@ -229,6 +249,8 @@ export const getAccountTokenTypes = type => {
     case 'bitcoin-86':
     case 'bittest-86':
       return [_AssetType.NATIVE, _AssetType.RUNE, _AssetType.BRC20];
+    case 'cardano':
+      return [_AssetType.NATIVE, _AssetType.CIP26];
     default:
       return [];
   }
@@ -253,7 +275,7 @@ export const getAccountTokenTypes = type => {
 export const transformAccount = (address, _type, meta, chainInfoMap, parentAccount) => {
   const signMode = getAccountSignMode(address, meta);
   const type = _type || getKeypairTypeByAddress(address);
-  const chainType = getAccountChainType(type);
+  const chainType = getAccountChainTypeFromKeypairType(type);
   let specialChain;
   if (!chainInfoMap) {
     return {
@@ -307,7 +329,7 @@ export const pairToAccount = ({
 export const transformAccounts = accounts => Object.values(accounts).map(data => singleAddressToAccount(data));
 export const transformAddress = (address, meta) => {
   const type = getKeypairTypeByAddress(address);
-  const chainType = getAccountChainType(type);
+  const chainType = getAccountChainTypeFromKeypairType(type);
   return {
     address,
     ...meta,
@@ -382,6 +404,7 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
     let tokenTypes = [];
     let accountActions = [];
     let specialChain;
+    let isNeedMigrateUnifiedAccount;
     if (value.accounts.length > 1) {
       accountType = AccountProxyType.UNIFIED;
       chainTypes = Array.from(value.accounts.reduce((rs, account) => rs.add(account.chainType), new Set()));
@@ -391,6 +414,9 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
         }
         return rs;
       }, new Set()));
+      if (chainTypes.length < SUPPORTED_ACCOUNT_CHAIN_TYPES.length) {
+        isNeedMigrateUnifiedAccount = true;
+      }
 
       /* Account actions */
 
@@ -422,6 +448,9 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
       if (account.chainType === AccountChainType.TON) {
         accountActions = accountActions.filter(action => action !== AccountActions.DERIVE);
       }
+      if (chainTypes.length === 1 && accountActions.includes(AccountActions.EXPORT_MNEMONIC) && account.isMasterAccount && account.type !== 'ton-native') {
+        isNeedMigrateUnifiedAccount = true;
+      }
       switch (account.signMode) {
         case AccountSignMode.GENERIC_LEDGER:
         case AccountSignMode.LEGACY_LEDGER:
@@ -435,7 +464,8 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
       chainTypes,
       specialChain,
       tokenTypes,
-      accountActions
+      accountActions,
+      isNeedMigrateUnifiedAccount
     }];
   }));
   const deepSearchParentId = parentId => {
@@ -511,15 +541,9 @@ export const combineAllAccountProxy = accountProxies => {
   const tokenTypes = new Set();
   const specialChain = accountProxies.length === 1 ? accountProxies[0].specialChain : undefined;
   for (const accountProxy of accountProxies) {
-    // Have 4 network types, but at the moment, we only support 3 network types
-    if (chainTypes.size === 3) {
-      break;
-    }
     for (const chainType of accountProxy.chainTypes) {
       chainTypes.add(chainType);
     }
-  }
-  for (const accountProxy of accountProxies) {
     for (const tokenType of accountProxy.tokenTypes) {
       tokenTypes.add(tokenType);
     }

package/utils/fee/transfer.d.ts

@@ -1,6 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { AmountData } from '@subwallet/extension-base/background/KoniTypes';
-import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { FeeChainType, FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
 import { ResponseSubscribeTransfer } from '@subwallet/extension-base/types/balance/transfer';
 export interface CalculateMaxTransferable extends TransactionFee {
@@ -12,6 +12,7 @@ export interface CalculateMaxTransferable extends TransactionFee {
     substrateApi: _SubstrateApi;
     evmApi: _EvmApi;
     tonApi: _TonApi;
+    cardanoApi: _CardanoApi;
     isTransferLocalTokenAndPayThatTokenAsFee: boolean;
     isTransferNativeTokenAndPayLocalTokenAsFee: boolean;
     nativeToken: _ChainAsset;