@subwallet/extension-base 1.2.31-0 → 1.2.33-0

package/types/yield/actions/others.d.ts

@@ -1,4 +1,4 @@
-import { BaseRequestSign, InternalRequestSign } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseRequestSign, InternalRequestSign } from '../../transaction';
 import { BasePoolInfo, UnstakingInfo, YieldPoolInfo } from '../info';
 /**
  * @interface YieldLeaveParams

package/utils/account/analyze.d.ts

@@ -0,0 +1,4 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { AccountProxy, AddressJson, ResponseInputAccountSubscribe } from '@subwallet/extension-base/types';
+export declare const _analyzeAddress: (data: string, accountProxies: AccountProxy[], contacts: AddressJson[], chainInfo: _ChainInfo, substrateApi?: _SubstrateApi) => Promise<Omit<ResponseInputAccountSubscribe, 'id'>>;

package/utils/account/analyze.js

@@ -0,0 +1,159 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { resolveAzeroAddressToDomain, resolveAzeroDomainToAddress } from '@subwallet/extension-base/koni/api/dotsama/domain';
+import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { AccountChainType, AnalyzedGroup } from '@subwallet/extension-base/types';
+import { isAddress } from '@polkadot/util-crypto';
+import { _reformatAddressWithChain, reformatAddress } from "./common.js";
+// TODO: Re-confirm to compare without
+const isStrValidWithAddress = (str, account, chainInfo) => {
+  if (account.chainType === AccountChainType.SUBSTRATE) {
+    const reformated = reformatAddress(account.address, _getChainSubstrateAddressPrefix(chainInfo));
+    if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  } else if (account.chainType === AccountChainType.TON) {
+    const isTestnet = chainInfo.isTestnet;
+    const reformated = reformatAddress(account.address, isTestnet ? 0 : 1);
+    if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  } else {
+    if (account.address.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  }
+  return 'invalid';
+};
+const isNameValid = (str, name) => {
+  if (name === str) {
+    return 'extracted';
+  } else if (name.includes(str)) {
+    return 'valid';
+  } else {
+    return 'invalid';
+  }
+};
+export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo, substrateApi) => {
+  if (!data) {
+    return {
+      options: []
+    };
+  }
+  const chain = chainInfo.slug;
+  const _data = data.trim().toLowerCase();
+  const options = [];
+  const currentChainType = _chainInfoToChainType(chainInfo);
+  let current;
+
+  // Filter account proxies
+  for (const accountProxy of accountProxies) {
+    const _name = accountProxy.name.trim().toLowerCase();
+    const nameCondition = isNameValid(_data, _name);
+    const filterAccounts = accountProxy.accounts.filter(account => account.chainType === currentChainType);
+    for (const account of filterAccounts) {
+      const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
+      const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
+      const rs = {
+        address: account.address,
+        proxyId: accountProxy.id,
+        analyzedGroup: AnalyzedGroup.WALLET,
+        displayName: accountProxy.name,
+        formatedAddress: _reformatAddressWithChain(account.address, chainInfo)
+      };
+      if (condition !== 'invalid') {
+        if (account.specialChain) {
+          if (account.specialChain === chain) {
+            options.push(rs);
+            if (condition === 'extracted') {
+              current = rs;
+            }
+          }
+        } else {
+          options.push(rs);
+          if (condition === 'extracted') {
+            current = rs;
+          }
+        }
+      }
+    }
+  }
+  const filterContacts = contacts.filter(contact => contact.chainType === currentChainType);
+
+  // Filter address book addresses
+  for (const contact of filterContacts) {
+    const name = (contact === null || contact === void 0 ? void 0 : contact.name) || '';
+    const _name = name.trim().toLowerCase();
+    const nameCondition = isNameValid(_data, _name);
+    const addressCondition = isStrValidWithAddress(_data, contact, chainInfo);
+    const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
+    const rs = {
+      address: contact.address,
+      analyzedGroup: contact.isRecent ? AnalyzedGroup.RECENT : AnalyzedGroup.CONTACT,
+      displayName: name,
+      formatedAddress: _reformatAddressWithChain(contact.address, chainInfo)
+    };
+    if (condition !== 'invalid') {
+      if (contact.isRecent) {
+        var _contact$recentChainS;
+        if ((_contact$recentChainS = contact.recentChainSlugs) !== null && _contact$recentChainS !== void 0 && _contact$recentChainS.includes(chain)) {
+          options.push(rs);
+          if (condition === 'extracted') {
+            current = rs;
+          }
+        }
+      } else {
+        options.push(rs);
+        if (condition === 'extracted') {
+          current = rs;
+        }
+      }
+    }
+  }
+  if (substrateApi) {
+    await (substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.isReady);
+    const _raw = data.trim();
+    if (chain === 'aleph' || chain === 'alephTest') {
+      if (isAddress(_raw)) {
+        const domain = await resolveAzeroAddressToDomain(_raw, chain, substrateApi.api);
+        if (domain) {
+          const rs = {
+            address: _raw,
+            analyzedGroup: AnalyzedGroup.DOMAIN,
+            displayName: domain,
+            formatedAddress: _reformatAddressWithChain(_raw, chainInfo)
+          };
+          options.push(rs);
+          if (!current) {
+            current = rs;
+          }
+        }
+      } else {
+        const address = await resolveAzeroDomainToAddress(_raw, chain, substrateApi.api);
+        if (address) {
+          const rs = {
+            address: address,
+            analyzedGroup: AnalyzedGroup.DOMAIN,
+            displayName: _raw,
+            formatedAddress: _reformatAddressWithChain(address, chainInfo)
+          };
+          options.push(rs);
+          if (!current) {
+            current = rs;
+          }
+        }
+      }
+    }
+  }
+  return {
+    options,
+    current
+  };
+};

package/utils/account/common.d.ts

@@ -0,0 +1,16 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+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[];
+};
+export declare function quickFormatAddressToCompare(address?: string): string | undefined;
+/** @deprecated */
+export declare const modifyAccountName: (type: KeypairType, name: string, modify: boolean) => string;

package/utils/account/common.js

@@ -0,0 +1,104 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
+export function isAccountAll(address) {
+  return address === ALL_ACCOUNT_KEY;
+}
+export function reformatAddress(address, networkPrefix = 42, isEthereum = false) {
+  try {
+    if (!address || address === '') {
+      return '';
+    }
+    if (isEthereumAddress(address)) {
+      return address;
+    }
+    if (isAccountAll(address)) {
+      return address;
+    }
+    const publicKey = decodeAddress(address);
+    if (isEthereum) {
+      return ethereumEncode(publicKey);
+    }
+    const type = getKeypairTypeByAddress(address);
+    if (networkPrefix < 0) {
+      return address;
+    }
+    return encodeAddress(publicKey, networkPrefix, type);
+  } catch (e) {
+    console.warn('Get error while reformat address', address, e);
+    return address;
+  }
+}
+export const _reformatAddressWithChain = (address, chainInfo) => {
+  const chainType = _chainInfoToChainType(chainInfo);
+  if (chainType === AccountChainType.SUBSTRATE) {
+    return reformatAddress(address, _getChainSubstrateAddressPrefix(chainInfo));
+  } else if (chainType === AccountChainType.TON) {
+    const isTestnet = chainInfo.isTestnet;
+    return reformatAddress(address, isTestnet ? 0 : 1);
+  } else {
+    return address;
+  }
+};
+export const getAccountChainTypeForAddress = address => {
+  const type = getKeypairTypeByAddress(address);
+  return getAccountChainType(type);
+};
+export function categoryAddresses(addresses) {
+  const substrate = [];
+  const evm = [];
+  const ton = [];
+  const bitcoin = [];
+  addresses.forEach(address => {
+    if (isEthereumAddress(address)) {
+      evm.push(address);
+    } else if (isTonAddress(address)) {
+      ton.push(address);
+    } else if (isBitcoinAddress(address)) {
+      bitcoin.push(address);
+    } else {
+      substrate.push(address);
+    }
+  });
+  return {
+    bitcoin,
+    evm,
+    substrate,
+    ton
+  };
+}
+export function quickFormatAddressToCompare(address) {
+  if (!isAddress(address)) {
+    return address;
+  }
+  return reformatAddress(address, 42).toLowerCase();
+}
+
+/** @deprecated */
+export const modifyAccountName = (type, name, modify) => {
+  if (!modify) {
+    return name;
+  }
+  let network = '';
+  switch (type) {
+    case 'sr25519':
+    case 'ed25519':
+    case 'ecdsa':
+      network = 'Substrate';
+      break;
+    case 'ethereum':
+      network = 'EVM';
+      break;
+    case 'ton':
+    case 'ton-native':
+      network = 'Ton';
+      break;
+  }
+  return network ? [name, network].join(' - ') : name;
+};

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

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './validate';

package/utils/account/derive/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./info/index.js";
+export * from "./validate.js";

package/utils/account/derive/info/index.d.ts

@@ -0,0 +1,2 @@
+export * from './solo';
+export * from './unified';

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

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./solo.js";
+export * from "./unified.js";

package/utils/account/derive/info/solo.d.ts

@@ -0,0 +1,11 @@
+import { AccountDeriveData, DeriveInfo, NextDerivePair } from '@subwallet/extension-base/types';
+import { KeypairType, KeyringPair } from '@subwallet/keyring/types';
+export declare const parseUnifiedSuriToDerivationPath: (suri: string, type: KeypairType) => string;
+export declare const getSoloDerivationInfo: (type: KeypairType, metadata?: AccountDeriveData) => DeriveInfo;
+/**
+ * @func findSoloNextDerive
+ * @return {NextDerivePair}
+ * */
+export declare const findSoloNextDerive: (parentAddress: string) => NextDerivePair;
+export declare const derivePair: (parentPair: KeyringPair, name: string, suri: string, derivationPath?: string) => KeyringPair;
+export declare const getSuri: (seed: string, type?: KeypairType) => string;

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

@@ -0,0 +1,230 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { getDerivePath } from '@subwallet/keyring';
+import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert } from '@polkadot/util';
+import { validateEvmDerivationPath, validateOtherSubstrateDerivationPath, validateSr25519DerivationPath, validateTonDerivationPath, validateUnifiedDerivationPath } from "../validate.js";
+export const parseUnifiedSuriToDerivationPath = (suri, type) => {
+  const reg = /^\/\/(\d+)(\/\/\d+)?$/;
+  if (suri.match(reg)) {
+    const [, firstIndex, secondData] = suri.match(reg);
+    const first = parseInt(firstIndex, 10);
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/\/(\d+)/);
+      if (type === 'ethereum') {
+        return `m/44'/60'/0'/0/${first}/${secondIndex}`;
+      } else if (type === 'ton') {
+        return `m/44'/607'/${first}'/${secondIndex}'`;
+      }
+    } else {
+      if (type === 'ethereum') {
+        return `m/44'/60'/0'/0/${first}`;
+      } else if (type === 'ton') {
+        return `m/44'/607'/${first}'`;
+      }
+    }
+    if (SubstrateKeypairTypes.includes(type)) {
+      return suri;
+    }
+  }
+  return '';
+};
+export const getSoloDerivationInfo = (type, metadata = {}) => {
+  const {
+    derivationPath: derivePath,
+    parentAddress,
+    suri
+  } = metadata;
+  if (suri) {
+    if (derivePath) {
+      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : () => undefined;
+      const validateTypeRs = validateTypeFunc(derivePath);
+      if (validateTypeRs) {
+        return {
+          suri: validateTypeRs.suri,
+          depth: validateTypeRs.depth,
+          derivationPath: derivePath,
+          parentAddress,
+          autoIndexes: validateTypeRs.autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    } else {
+      if (SubstrateKeypairTypes.includes(type)) {
+        const _type = type;
+        const validateTypeFunc = _type === 'sr25519' ? validateSr25519DerivationPath : raw => validateOtherSubstrateDerivationPath(raw, _type);
+        const validateTypeRs = validateTypeFunc(suri);
+        if (validateTypeRs) {
+          return {
+            suri: validateTypeRs.suri,
+            depth: validateTypeRs.depth,
+            parentAddress,
+            autoIndexes: validateTypeRs.autoIndexes
+          };
+        }
+      }
+      const validateUnifiedRs = validateUnifiedDerivationPath(suri);
+      if (validateUnifiedRs) {
+        const {
+          autoIndexes,
+          depth
+        } = validateUnifiedRs;
+        const derivationPath = parseUnifiedSuriToDerivationPath(suri, type);
+        return {
+          suri: suri,
+          depth,
+          derivationPath: derivationPath,
+          parentAddress,
+          autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    }
+  } else {
+    if (derivePath) {
+      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : () => undefined;
+      const validateTypeRs = validateTypeFunc(derivePath);
+      if (validateTypeRs) {
+        return {
+          suri: validateTypeRs.suri,
+          depth: validateTypeRs.depth,
+          derivationPath: derivePath,
+          parentAddress,
+          autoIndexes: validateTypeRs.autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    }
+  }
+  return {
+    depth: 0,
+    parentAddress,
+    suri: suri
+  };
+};
+
+/**
+ * @func findSoloNextDerive
+ * @return {NextDerivePair}
+ * */
+export const findSoloNextDerive = parentAddress => {
+  var _deriveInfo$autoIndex;
+  let parentPair;
+  try {
+    parentPair = keyring.getPair(parentAddress);
+  } catch (e) {}
+  assert(parentPair, t('Unable to find account'));
+  const deriveInfo = getSoloDerivationInfo(parentPair.type, parentPair.meta);
+  const needChangeRoot = deriveInfo.depth > 0;
+  let rootPair;
+  if (needChangeRoot) {
+    try {
+      rootPair = keyring.getPair(parentPair.meta.parentAddress || '');
+    } catch (e) {}
+  } else {
+    rootPair = parentPair;
+  }
+  assert(rootPair, t('Unable to find parent account'));
+  const rootAddress = rootPair.address;
+  const currentDepth = deriveInfo.depth;
+  const currentIndex = (_deriveInfo$autoIndex = deriveInfo.autoIndexes) === null || _deriveInfo$autoIndex === void 0 ? void 0 : _deriveInfo$autoIndex[currentDepth - 1];
+  const pairs = keyring.getPairs();
+  const children = pairs.filter(p => p.meta.parentAddress === rootAddress);
+  const childrenMetadata = children.map(({
+    meta,
+    type
+  }) => getSoloDerivationInfo(type, meta)).filter(({
+    autoIndexes,
+    depth
+  }) => {
+    return depth === currentDepth + 1 && currentIndex === (autoIndexes === null || autoIndexes === void 0 ? void 0 : autoIndexes[currentDepth - 1]);
+  }).sort((a, b) => {
+    var _a$autoIndexes, _b$autoIndexes;
+    const aDeriveIndex = (_a$autoIndexes = a.autoIndexes) === null || _a$autoIndexes === void 0 ? void 0 : _a$autoIndexes[currentDepth];
+    const bDeriveIndex = (_b$autoIndexes = b.autoIndexes) === null || _b$autoIndexes === void 0 ? void 0 : _b$autoIndexes[currentDepth];
+    if (aDeriveIndex !== undefined && bDeriveIndex !== undefined) {
+      return aDeriveIndex - bDeriveIndex;
+    } else {
+      if (aDeriveIndex === undefined && bDeriveIndex === undefined) {
+        return 0;
+      } else {
+        return aDeriveIndex === undefined ? 1 : -1;
+      }
+    }
+  });
+  let index = currentDepth === 0 ? 1 : 0;
+  for (const {
+    autoIndexes,
+    suri
+  } of childrenMetadata) {
+    const _autoIndexes = autoIndexes;
+    const deriveIndex = _autoIndexes[currentDepth];
+    if (!suri || deriveIndex === undefined) {
+      break;
+    }
+    if (deriveIndex === index) {
+      index++;
+    } else {
+      break;
+    }
+  }
+  const isSubstrate = SubstrateKeypairTypes.includes(parentPair.type);
+  const indexes = currentDepth > 0 ? deriveInfo.autoIndexes || [] : [];
+  indexes.push(index);
+  const suri = isSubstrate ? [deriveInfo.suri || '', index].join('//') : '//'.concat(indexes.join('//'));
+  return {
+    deriveIndex: index,
+    depth: currentDepth + 1,
+    derivationPath: parseUnifiedSuriToDerivationPath(suri, rootPair.type),
+    suri,
+    deriveAddress: rootAddress
+  };
+};
+export const derivePair = (parentPair, name, suri, derivationPath) => {
+  var _parentPair$ton;
+  if (parentPair.isLocked) {
+    keyring.unlockPair(parentPair.address);
+  }
+  const isEvm = EthereumKeypairTypes.includes(parentPair.type);
+  const isTon = parentPair.type === 'ton';
+  const meta = {
+    name,
+    parentAddress: parentPair.address,
+    suri: suri,
+    derivationPath,
+    tonContractVersion: undefined
+  };
+  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);
+  } else {
+    return parentPair.substrate.derive(suri, meta);
+  }
+};
+export const getSuri = (seed, type) => {
+  const extraPath = type ? getDerivePath(type)(0) : '';
+  return seed + (extraPath ? '/' + extraPath : '');
+};

package/utils/account/derive/info/unified.d.ts

@@ -0,0 +1,7 @@
+import { AccountProxyMap, DeriveInfo, NextDerivePair } from '@subwallet/extension-base/types';
+export declare const getUnifiedDerivationInfo: (suri?: string) => DeriveInfo;
+/**
+ * @func findUnifiedNextDerive
+ * @return {NextDerivePair}
+ * */
+export declare const findUnifiedNextDerive: (proxyId: string, accounts: AccountProxyMap) => NextDerivePair;

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

@@ -0,0 +1,102 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountProxyType } from '@subwallet/extension-base/types';
+import { validateUnifiedDerivationPath } from "../validate.js";
+import { getSoloDerivationInfo } from "./solo.js";
+export const getUnifiedDerivationInfo = suri => {
+  if (suri) {
+    const validateUnifiedRs = validateUnifiedDerivationPath(suri);
+    if (validateUnifiedRs) {
+      const {
+        autoIndexes,
+        depth
+      } = validateUnifiedRs;
+      return {
+        suri: suri,
+        depth,
+        autoIndexes
+      };
+    }
+  }
+  return {
+    depth: 0,
+    suri
+  };
+};
+
+/**
+ * @func findUnifiedNextDerive
+ * @return {NextDerivePair}
+ * */
+export const findUnifiedNextDerive = (proxyId, accounts) => {
+  var _deriveInfo$autoIndex, _parentProxy$children;
+  const currentProxy = accounts[proxyId];
+  const parentProxyId = currentProxy.parentId || currentProxy.id;
+  const parentProxy = accounts[parentProxyId];
+  const deriveInfo = getUnifiedDerivationInfo(currentProxy.suri);
+  const currentDepth = deriveInfo.depth;
+  const currentIndex = (_deriveInfo$autoIndex = deriveInfo.autoIndexes) === null || _deriveInfo$autoIndex === void 0 ? void 0 : _deriveInfo$autoIndex[currentDepth - 1];
+  const children = ((_parentProxy$children = parentProxy.children) === null || _parentProxy$children === void 0 ? void 0 : _parentProxy$children.map(id => accounts[id])) || [];
+  const childrenMetadata = children.map(({
+    accountType,
+    accounts,
+    suri
+  }) => {
+    if (accountType === AccountProxyType.UNIFIED) {
+      return getUnifiedDerivationInfo(suri);
+    } else {
+      const account = accounts[0];
+      return getSoloDerivationInfo(account.type, account);
+    }
+  }).filter(({
+    autoIndexes,
+    depth
+  }) => {
+    if (depth !== currentDepth + 1) {
+      return false;
+    }
+    if (autoIndexes !== null && autoIndexes !== void 0 && autoIndexes.includes(undefined)) {
+      return false;
+    }
+    return currentIndex === (autoIndexes === null || autoIndexes === void 0 ? void 0 : autoIndexes[currentDepth - 1]);
+  }).sort((a, b) => {
+    var _a$autoIndexes, _b$autoIndexes;
+    const aDeriveIndex = (_a$autoIndexes = a.autoIndexes) === null || _a$autoIndexes === void 0 ? void 0 : _a$autoIndexes[currentDepth];
+    const bDeriveIndex = (_b$autoIndexes = b.autoIndexes) === null || _b$autoIndexes === void 0 ? void 0 : _b$autoIndexes[currentDepth];
+    if (aDeriveIndex !== undefined && bDeriveIndex !== undefined) {
+      return aDeriveIndex - bDeriveIndex;
+    } else {
+      if (aDeriveIndex === undefined && bDeriveIndex === undefined) {
+        return 0;
+      } else {
+        return aDeriveIndex === undefined ? 1 : -1;
+      }
+    }
+  });
+  let index = currentDepth === 0 ? 1 : 0;
+  for (const {
+    autoIndexes,
+    suri
+  } of childrenMetadata) {
+    const _autoIndexes = autoIndexes;
+    const deriveIndex = _autoIndexes[currentDepth];
+    if (!suri || deriveIndex === undefined) {
+      break;
+    }
+    if (deriveIndex === index) {
+      index++;
+    } else {
+      break;
+    }
+  }
+  const indexes = currentDepth > 0 ? deriveInfo.autoIndexes || [] : [];
+  indexes.push(index);
+  const suri = '//'.concat(indexes.join('//'));
+  return {
+    deriveIndex: index,
+    depth: currentDepth + 1,
+    suri,
+    deriveAddress: parentProxy.id
+  };
+};

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

@@ -0,0 +1,8 @@
+import { DerivePathInfo, IDerivePathInfo_ } from '@subwallet/extension-base/types';
+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 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;