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

package/services/transaction-service/types.d.ts

@@ -1,4 +1,5 @@
 import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
+import { SignTypedDataMessageV3V4 } from '@subwallet/extension-base/core/logic-validation';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
 import { BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
 import EventEmitter from 'eventemitter3';
@@ -27,6 +28,9 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     signAfterCreate?: (id: string) => void;
     step?: BriefProcessStep;
 }
+export interface SWPermitTransaction extends Omit<SWTransaction, 'transaction'> {
+    transaction: SignTypedDataMessageV3V4;
+}
 export interface SWTransactionResult extends Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler' | 'process'> {
     process?: ProcessTransactionData;
 }
@@ -42,6 +46,9 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
     resolveOnDone?: boolean;
     skipFeeValidation?: boolean;
 }
+export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
+    transaction?: SWPermitTransaction['transaction'] | null;
+}
 export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>> & TransactionFee & {
     processId?: string;
 };

package/services/transaction-service/utils.js

@@ -1,8 +1,10 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getBlockExplorerFromChain, _isChainTestNet, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getBlockExplorerFromChain, _isChainTestNet, _isPureCardanoChain, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { CHAIN_FLIP_MAINNET_EXPLORER, CHAIN_FLIP_TESTNET_EXPLORER, SIMPLE_SWAP_EXPLORER } from '@subwallet/extension-base/services/swap-service/utils';
+import { hexAddPrefix, isHex } from '@polkadot/util';
+
 // @ts-ignore
 export function parseTransactionData(data) {
   // @ts-ignore
@@ -46,6 +48,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (_isPureEvmChain(chainInfo)) {
     return 'tx';
   }
+  if (_isPureCardanoChain(chainInfo)) {
+    return 'transaction';
+  }
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
@@ -60,7 +65,7 @@ export function getExplorerLink(chainInfo, value, type) {
     const route = getBlockExplorerAccountRoute(explorerLink);
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
-  if (explorerLink && value.startsWith('0x')) {
+  if (explorerLink && isHex(hexAddPrefix(value))) {
     if (chainInfo.slug === 'bittensor') {
       return undefined;
     }

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

@@ -112,8 +112,11 @@ export declare enum AccountChainType {
     SUBSTRATE = "substrate",
     ETHEREUM = "ethereum",
     BITCOIN = "bitcoin",
-    TON = "ton"
+    TON = "ton",
+    CARDANO = "cardano"
 }
+export declare const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP: Record<string, number>;
+export declare const SUPPORTED_ACCOUNT_CHAIN_TYPES: string[];
 export declare enum AccountActions {
     DERIVE = "DERIVE",
     EXPORT_MNEMONIC = "EXPORT_MNEMONIC",

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/option.d.ts

@@ -4,5 +4,5 @@ export declare type FeeOption = FeeDefaultOption | 'custom';
 export declare type TransactionFee = {
     feeOption?: FeeOption;
     feeCustom?: FeeCustom;
-    nonNativeTokenPayFeeSlug?: string;
+    tokenPayFeeSlug?: string;
 };

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[];