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

package/utils/account/transform.js

@@ -0,0 +1,533 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 { getKeypairTypeByAddress, tonMnemonicToEntropy } from '@subwallet/keyring';
+import { BitcoinKeypairTypes, 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';
+import { getSoloDerivationInfo } from "./derive/index.js";
+export const createAccountProxyId = (_suri, derivationPath) => {
+  let data = _suri;
+  if (mnemonicValidate(_suri)) {
+    const entropy = mnemonicToEntropy(_suri);
+    data = u8aToHex(entropy);
+    if (derivationPath) {
+      data = blake2AsHex(data, 256);
+    }
+  } else if (tonMnemonicValidate(_suri)) {
+    const entropy = tonMnemonicToEntropy(_suri);
+    data = u8aToHex(entropy);
+    if (derivationPath) {
+      data = blake2AsHex(data, 256);
+    }
+  }
+  if (derivationPath) {
+    data = hexStripPrefix(data).concat(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 getAccountSignMode = (address, _meta) => {
+  const meta = _meta;
+  if (!address || !meta) {
+    return AccountSignMode.UNKNOWN;
+  } else {
+    if (address === ALL_ACCOUNT_KEY) {
+      return AccountSignMode.ALL_ACCOUNT;
+    } else {
+      if (meta.isInjected) {
+        return AccountSignMode.INJECTED;
+      }
+      if (meta.isExternal) {
+        if (meta.isHardware) {
+          if (meta.isGeneric) {
+            return AccountSignMode.GENERIC_LEDGER;
+          } else {
+            return AccountSignMode.LEGACY_LEDGER;
+          }
+        } else if (meta.isReadOnly) {
+          return AccountSignMode.READ_ONLY;
+        } else {
+          return AccountSignMode.QR;
+        }
+      } else {
+        return AccountSignMode.PASSWORD;
+      }
+    }
+  }
+};
+export const getAccountActions = (signMode, networkType, type, _meta, parentAccount) => {
+  const result = [];
+  const meta = _meta;
+
+  // JSON
+  if (signMode === AccountSignMode.PASSWORD) {
+    result.push(AccountActions.EXPORT_JSON);
+  }
+
+  // Mnemonic
+  if (meta && meta.isMasterAccount) {
+    result.push(AccountActions.EXPORT_MNEMONIC);
+  }
+
+  // Private key
+  if (signMode === AccountSignMode.PASSWORD) {
+    if (networkType === AccountChainType.ETHEREUM || networkType === AccountChainType.TON) {
+      result.push(AccountActions.EXPORT_PRIVATE_KEY);
+    }
+  }
+
+  // QR
+  if (signMode === AccountSignMode.PASSWORD) {
+    if (networkType === AccountChainType.ETHEREUM || networkType === AccountChainType.SUBSTRATE) {
+      result.push(AccountActions.EXPORT_QR);
+    }
+  }
+
+  // Derive
+  if (signMode === AccountSignMode.PASSWORD) {
+    const deriveInfo = getSoloDerivationInfo(type, meta);
+    if (networkType === AccountChainType.SUBSTRATE) {
+      if (deriveInfo.depth === 0) {
+        result.push(AccountActions.DERIVE);
+      } else if (deriveInfo.depth === 1) {
+        if (parentAccount && parentAccount.accountActions.includes(AccountActions.DERIVE)) {
+          result.push(AccountActions.DERIVE);
+        }
+      }
+    } else if (type !== 'ton-native') {
+      if (deriveInfo.depth === 0) {
+        if (meta && meta.isMasterAccount) {
+          result.push(AccountActions.DERIVE);
+        }
+      } else if (deriveInfo.depth === 1) {
+        if (parentAccount && parentAccount.accountActions.includes(AccountActions.DERIVE)) {
+          result.push(AccountActions.DERIVE);
+        }
+      }
+    }
+  }
+
+  // Ton change wallet contract version
+  if (networkType === AccountChainType.TON && signMode !== AccountSignMode.READ_ONLY) {
+    result.push(AccountActions.TON_CHANGE_WALLET_CONTRACT_VERSION);
+  }
+  return result;
+};
+const BASE_TRANSFER_ACTIONS = [ExtrinsicType.TRANSFER_BALANCE, ExtrinsicType.TRANSFER_TOKEN];
+const NATIVE_STAKE_ACTIONS = [ExtrinsicType.STAKING_BOND, ExtrinsicType.STAKING_UNBOND, ExtrinsicType.STAKING_WITHDRAW,
+// ExtrinsicType.STAKING_COMPOUNDING,
+// ExtrinsicType.STAKING_CANCEL_COMPOUNDING,
+ExtrinsicType.STAKING_CANCEL_UNSTAKE];
+const POOL_STAKE_ACTIONS = [ExtrinsicType.STAKING_JOIN_POOL, ExtrinsicType.STAKING_LEAVE_POOL, ExtrinsicType.STAKING_POOL_WITHDRAW, ExtrinsicType.STAKING_CLAIM_REWARD, ExtrinsicType.JOIN_YIELD_POOL];
+const EARN_VDOT_ACTIONS = [ExtrinsicType.MINT_VDOT, ExtrinsicType.REDEEM_VDOT, ExtrinsicType.UNSTAKE_VDOT];
+const EARN_LDOT_ACTIONS = [ExtrinsicType.MINT_LDOT, ExtrinsicType.REDEEM_LDOT, ExtrinsicType.UNSTAKE_LDOT];
+const EARN_SDOT_ACTIONS = [ExtrinsicType.MINT_SDOT, ExtrinsicType.REDEEM_SDOT, ExtrinsicType.UNSTAKE_SDOT];
+const EARN_QDOT_ACTIONS = [ExtrinsicType.MINT_QDOT, ExtrinsicType.REDEEM_QDOT, ExtrinsicType.UNSTAKE_QDOT];
+const EARN_STDOT_ACTIONS = [ExtrinsicType.MINT_STDOT, ExtrinsicType.REDEEM_STDOT, ExtrinsicType.UNSTAKE_STDOT];
+const EARN_VMANTA_ACTIONS = [ExtrinsicType.MINT_VMANTA, ExtrinsicType.REDEEM_VMANTA, ExtrinsicType.UNSTAKE_VMANTA];
+const EVM_ACTIONS = [ExtrinsicType.TOKEN_SPENDING_APPROVAL, ExtrinsicType.EVM_EXECUTE];
+const OTHER_ACTIONS = [ExtrinsicType.TRANSFER_XCM, ExtrinsicType.SEND_NFT, ExtrinsicType.SWAP, ExtrinsicType.CROWDLOAN];
+export const getAccountTransactionActions = (signMode, networkType, type, _meta, _specialNetwork) => {
+  if ([AccountSignMode.PASSWORD, AccountSignMode.INJECTED].includes(signMode)) {
+    switch (networkType) {
+      case AccountChainType.SUBSTRATE:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...OTHER_ACTIONS];
+      case AccountChainType.ETHEREUM:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...EVM_ACTIONS];
+      case AccountChainType.TON:
+        return [...BASE_TRANSFER_ACTIONS];
+    }
+  } else if (signMode === AccountSignMode.QR) {
+    switch (networkType) {
+      case AccountChainType.SUBSTRATE:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...OTHER_ACTIONS];
+      case AccountChainType.ETHEREUM:
+        return [...(isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
+      case AccountChainType.TON:
+        return [];
+    }
+  } else if (signMode === AccountSignMode.GENERIC_LEDGER) {
+    switch (networkType) {
+      case AccountChainType.SUBSTRATE:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_VMANTA_ACTIONS,
+        // ...EARN_LDOT_ACTIONS,
+        // ...EARN_SDOT_ACTIONS,
+        // ...EARN_QDOT_ACTIONS,
+        ...OTHER_ACTIONS];
+      case AccountChainType.ETHEREUM:
+        return [...BASE_TRANSFER_ACTIONS, ...EARN_STDOT_ACTIONS, ...EVM_ACTIONS, ExtrinsicType.STAKING_WITHDRAW,
+        // For liquid staking
+        ExtrinsicType.SEND_NFT, ExtrinsicType.SWAP];
+      case AccountChainType.TON:
+        return [...BASE_TRANSFER_ACTIONS];
+    }
+  } else if (signMode === AccountSignMode.LEGACY_LEDGER) {
+    // Only for Substrate
+    const result = [];
+    const specialNetwork = _specialNetwork || '';
+    result.push(...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ExtrinsicType.SWAP, ExtrinsicType.CROWDLOAN);
+
+    // NFT
+    if (!['astar', 'avail_mainnet'].includes(specialNetwork)) {
+      result.push(ExtrinsicType.SEND_NFT);
+    }
+
+    // Earning
+    if (specialNetwork === 'bifrost') {
+      result.push(...EARN_VDOT_ACTIONS, ...EARN_VMANTA_ACTIONS);
+    }
+
+    // if (specialNetwork === 'acala') {
+    //   result.push(...EARN_LDOT_ACTIONS);
+    // }
+
+    // if (specialNetwork === 'parallel') {
+    //   result.push(...EARN_SDOT_ACTIONS);
+    // }
+
+    // if (specialNetwork === 'interlay') {
+    //   result.push(...EARN_QDOT_ACTIONS);
+    // }
+
+    // Transfer XCM
+    if (['polkadot', 'kusama', 'statemint', 'statemine'].includes(specialNetwork)) {
+      result.push(ExtrinsicType.TRANSFER_XCM);
+    }
+    return result;
+  }
+  return [];
+};
+export const getAccountTokenTypes = type => {
+  switch (type) {
+    case 'ethereum':
+      return [_AssetType.NATIVE, _AssetType.LOCAL, _AssetType.ERC20, _AssetType.ERC721];
+    case 'sr25519':
+    case 'ed25519':
+    case 'ecdsa':
+      return [_AssetType.NATIVE, _AssetType.LOCAL, _AssetType.PSP22, _AssetType.PSP34, _AssetType.GRC20, _AssetType.ERC721, _AssetType.VFT];
+    case 'ton':
+    case 'ton-native':
+      return [_AssetType.NATIVE, _AssetType.TEP74];
+    case 'bitcoin-44':
+    case 'bittest-44':
+    case 'bitcoin-84':
+    case 'bittest-84':
+      return [_AssetType.NATIVE];
+    case 'bitcoin-86':
+    case 'bittest-86':
+      return [_AssetType.NATIVE, _AssetType.RUNE, _AssetType.BRC20];
+    default:
+      return [];
+  }
+};
+
+/**
+ * Transforms account data into an `AccountJson` object.
+ *
+ * @param {string} address - The address of the account.
+ * @param {KeypairType} [_type] - The type of the keypair (optional).
+ * @param {KeyringPair$Meta} [meta] - Metadata associated with the keyring pair (optional).
+ * @param {Record<string, _ChainInfo>} [chainInfoMap] - A map of chain information (optional).
+ * If chain information is provided, add full data to account.
+ * @returns {AccountJson} The transformed account data.
+ *
+ * This function performs the following steps:
+ * 1. Determines the sign mode of the account based on the address and metadata.
+ * 2. Determines the network type of the account based on the keypair type.
+ * 3. If chain information is provided, add full data (accountActions, transactionActions) to account.
+ * 4. Returns an `AccountJson` object containing the transformed account data.
+ */
+export const transformAccount = (address, _type, meta, chainInfoMap, parentAccount) => {
+  const signMode = getAccountSignMode(address, meta);
+  const type = _type || getKeypairTypeByAddress(address);
+  const chainType = getAccountChainType(type);
+  let specialChain;
+  if (!chainInfoMap) {
+    return {
+      address,
+      ...meta,
+      type,
+      accountActions: [],
+      transactionActions: [],
+      tokenTypes: [],
+      signMode,
+      chainType
+    };
+  }
+  const genesisHash = meta === null || meta === void 0 ? void 0 : meta.genesisHash;
+  if (chainInfoMap && signMode === AccountSignMode.LEGACY_LEDGER && genesisHash) {
+    const chainInfo = Object.values(chainInfoMap).find(info => _getSubstrateGenesisHash(info) === genesisHash);
+    if (chainInfo) {
+      specialChain = chainInfo.slug;
+    }
+  }
+  const accountActions = getAccountActions(signMode, chainType, type, meta, parentAccount);
+  const transactionActions = getAccountTransactionActions(signMode, chainType, type, meta, specialChain);
+  const tokenTypes = getAccountTokenTypes(type);
+
+  /* Account actions */
+
+  return {
+    address,
+    ...meta,
+    type,
+    accountActions,
+    transactionActions,
+    signMode,
+    chainType,
+    specialChain,
+    tokenTypes
+  };
+};
+export const singleAddressToAccount = ({
+  json: {
+    address,
+    meta
+  },
+  type
+}, chainInfoMap, parentAccount) => transformAccount(address, type, meta, chainInfoMap, parentAccount);
+export const pairToAccount = ({
+  address,
+  meta,
+  type
+}, chainInfoMap, parentAccount) => transformAccount(address, type, meta, chainInfoMap, parentAccount);
+export const transformAccounts = accounts => Object.values(accounts).map(data => singleAddressToAccount(data));
+export const transformAddress = (address, meta) => {
+  const type = getKeypairTypeByAddress(address);
+  const chainType = getAccountChainType(type);
+  return {
+    address,
+    ...meta,
+    chainType
+  };
+};
+export const transformAddresses = addresses => Object.values(addresses).map(({
+  json: {
+    address,
+    meta
+  }
+}) => transformAddress(address, meta));
+export const convertAccountProxyType = accountSignMode => {
+  switch (accountSignMode) {
+    case AccountSignMode.GENERIC_LEDGER:
+    case AccountSignMode.LEGACY_LEDGER:
+      return AccountProxyType.LEDGER;
+    case AccountSignMode.QR:
+      return AccountProxyType.QR;
+    case AccountSignMode.READ_ONLY:
+      return AccountProxyType.READ_ONLY;
+    case AccountSignMode.INJECTED:
+      return AccountProxyType.INJECTED;
+    case AccountSignMode.PASSWORD:
+      return AccountProxyType.SOLO;
+    case AccountSignMode.ALL_ACCOUNT:
+      return AccountProxyType.ALL_ACCOUNT;
+    case AccountSignMode.UNKNOWN:
+      return AccountProxyType.UNKNOWN;
+  }
+  return AccountProxyType.UNKNOWN;
+};
+export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
+  const temp = {};
+  for (const account of accounts) {
+    const address = account.address;
+    const modifyPair = modifyPairs[address];
+    if (modifyPair && modifyPair.accountProxyId) {
+      const accountGroup = accountProxies[modifyPair.accountProxyId];
+      if (accountGroup) {
+        if (!temp[accountGroup.id]) {
+          temp[accountGroup.id] = {
+            ...accountGroup,
+            accounts: [],
+            chainTypes: [],
+            tokenTypes: [],
+            accountActions: []
+          };
+        }
+        account.proxyId = accountGroup.id;
+        temp[accountGroup.id].accounts.push(account);
+        continue;
+      }
+    }
+    temp[address] = {
+      id: address,
+      name: account.name || account.address,
+      accounts: [{
+        ...account,
+        proxyId: address
+      }],
+      chainTypes: [account.chainType],
+      parentId: account.parentAddress,
+      suri: account.derivationPath || account.suri,
+      tokenTypes: account.tokenTypes,
+      accountActions: []
+    };
+  }
+  const result = Object.fromEntries(Object.entries(temp).map(([key, value]) => {
+    let accountType = AccountProxyType.UNKNOWN;
+    let chainTypes = [];
+    let tokenTypes = [];
+    let accountActions = [];
+    let specialChain;
+    if (value.accounts.length > 1) {
+      accountType = AccountProxyType.UNIFIED;
+      chainTypes = Array.from(value.accounts.reduce((rs, account) => rs.add(account.chainType), new Set()));
+      tokenTypes = Array.from(value.accounts.reduce((rs, account) => {
+        for (const tokenType of account.tokenTypes) {
+          rs.add(tokenType);
+        }
+        return rs;
+      }, new Set()));
+
+      /* Account actions */
+
+      // Mnemonic
+      if (value.accounts.every(account => account.accountActions.includes(AccountActions.EXPORT_MNEMONIC))) {
+        accountActions.push(AccountActions.EXPORT_MNEMONIC);
+      }
+
+      // // Json
+      // if (value.accounts.every((account) => account.accountActions.includes(AccountActions.EXPORT_JSON))) {
+      //   accountActions.push(AccountActions.EXPORT_JSON);
+      // }
+
+      // Derive
+      if (value.accounts.every(account => account.accountActions.includes(AccountActions.DERIVE))) {
+        accountActions.push(AccountActions.DERIVE);
+      }
+
+      // Ton change wallet contract version
+      if (value.accounts.some(account => account.accountActions.includes(AccountActions.TON_CHANGE_WALLET_CONTRACT_VERSION))) {
+        accountActions.push(AccountActions.TON_CHANGE_WALLET_CONTRACT_VERSION);
+      }
+    } else if (value.accounts.length === 1) {
+      const account = value.accounts[0];
+      chainTypes = [account.chainType];
+      tokenTypes = account.tokenTypes;
+      accountType = convertAccountProxyType(account.signMode);
+      accountActions = account.accountActions;
+      if (account.chainType === AccountChainType.TON) {
+        accountActions = accountActions.filter(action => action !== AccountActions.DERIVE);
+      }
+      switch (account.signMode) {
+        case AccountSignMode.GENERIC_LEDGER:
+        case AccountSignMode.LEGACY_LEDGER:
+          specialChain = account.specialChain;
+          break;
+      }
+    }
+    return [key, {
+      ...value,
+      accountType,
+      chainTypes,
+      specialChain,
+      tokenTypes,
+      accountActions
+    }];
+  }));
+  const deepSearchParentId = parentId => {
+    const parent = result[parentId];
+    if (parent && parent.parentId) {
+      return deepSearchParentId(parent.parentId);
+    }
+    return parentId;
+  };
+  for (const value of Object.values(result)) {
+    if (value.parentId) {
+      value.parentId = deepSearchParentId(value.parentId);
+    }
+  }
+  const deepSearchChildren = id => {
+    const rs = [];
+    for (const accountProxy of Object.values(result)) {
+      if (accountProxy.parentId === id) {
+        rs.push(accountProxy.id);
+      }
+    }
+    return rs;
+  };
+  for (const value of Object.values(result)) {
+    value.children = deepSearchChildren(value.id);
+  }
+  return result;
+};
+
+/**
+ * @summary Use for `AccountContext` subscribe account
+ * */
+export const combineAccountsWithSubjectInfo = (pairs, modifyPairs, accountProxies, chainInfoMap) => {
+  const accountMap = {};
+  const convertAccount = address => {
+    const value = pairs[address];
+    if (!value) {
+      throw new Error(`Unable to retrieve account '${address}'`);
+    }
+    const {
+      json: {
+        meta
+      }
+    } = value;
+    if (accountMap[address]) {
+      return accountMap[address];
+    }
+    const {
+      parentAddress
+    } = meta;
+    let parentAccount;
+    if (parentAddress) {
+      parentAccount = accountMap[parentAddress];
+      if (!parentAccount && pairs[parentAddress]) {
+        parentAccount = convertAccount(parentAddress);
+      }
+    }
+    const rs = singleAddressToAccount(value, chainInfoMap, parentAccount);
+    accountMap[address] = rs;
+    return rs;
+  };
+  for (const address of Object.keys(pairs)) {
+    convertAccount(address);
+  }
+  return _combineAccounts(Object.values(accountMap), modifyPairs, accountProxies);
+};
+export const combineAccountsWithKeyPair = (pairs, modifyPairs, accountProxies, chainInfoMap) => {
+  const accounts = Object.values(pairs).map(data => pairToAccount(data, chainInfoMap));
+  return _combineAccounts(accounts, modifyPairs || {}, accountProxies || {});
+};
+export const combineAllAccountProxy = accountProxies => {
+  const chainTypes = new Set();
+  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);
+    }
+  }
+  return {
+    id: ALL_ACCOUNT_KEY,
+    name: 'All',
+    accounts: [],
+    accountActions: [],
+    accountType: AccountProxyType.ALL_ACCOUNT,
+    chainTypes: Array.from(chainTypes),
+    tokenTypes: Array.from(tokenTypes),
+    specialChain
+  };
+};

package/utils/auth.d.ts

@@ -0,0 +1,2 @@
+import { AccountAuthType } from '@subwallet/extension-base/background/types';
+export declare const isAddressValidWithAuthType: (address: string, accountAuthTypes?: AccountAuthType[]) => boolean;

package/utils/auth.js

@@ -0,0 +1,39 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
+import { EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+export const isAddressValidWithAuthType = (address, accountAuthTypes) => {
+  const keypairType = getKeypairTypeByAddress(address);
+  const validTypes = {
+    evm: EthereumKeypairTypes,
+    substrate: SubstrateKeypairTypes,
+    ton: TonKeypairTypes
+  };
+  return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
+    var _validTypes$authType;
+    return (_validTypes$authType = validTypes[authType]) === null || _validTypes$authType === void 0 ? void 0 : _validTypes$authType.includes(keypairType);
+  }));
+};
+
+// export const isAddressValidWithAuthType = (address: string, accountAuthType?: AccountAuthType): boolean => {
+//   const keypairType = getKeypairTypeByAddress(address);
+//
+//   if (!['ethereum', 'bitcoin-84', 'bitcoin-86', 'bittest-84', 'bittest-86'].includes(keypairType)) {
+//     return false;
+//   }
+//
+//   if (accountAuthType === 'both') {
+//     return true;
+//   }
+//
+//   if (accountAuthType === 'evm') {
+//     return keypairType === 'ethereum';
+//   }
+//
+//   if (accountAuthType === 'bitcoin') {
+//     return ['bitcoin-86', 'bittest-86', 'bitcoin-84', 'bittest-84'].includes(keypairType);
+//   }
+//
+//   return false;
+// };

package/utils/canDerive.d.ts

@@ -1,2 +1,2 @@
-import type { KeypairType } from '@polkadot/util-crypto/types';
+import type { KeypairType } from '@subwallet/keyring/types';
 export declare function canDerive(type?: KeypairType): boolean;

package/utils/eth/mergeTransactionAndSignature.d.ts

@@ -1,2 +1,2 @@
-import { Web3Transaction } from '@subwallet/extension-base/signers/types';
+import { Web3Transaction } from '@subwallet/extension-base/types';
 export declare const mergeTransactionAndSignature: (tx: Web3Transaction, _rawSignature: `0x${string}`) => `0x${string}`;

package/utils/getId.d.ts

@@ -1 +1,2 @@
 export declare function getId(): string;
+export declare const generateRandomString: (length?: number) => string;

package/utils/getId.js

@@ -1,8 +1,10 @@
 // Copyright 2019-2022 @polkadot/extension authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { randomAsU8a } from '@polkadot/util-crypto';
 import { ID_PREFIX } from "../defaults.js";
 let counter = 0;
 export function getId() {
   return `${ID_PREFIX}.${Date.now()}.${++counter}`;
-}
+}
+export const generateRandomString = (length = 6) => Buffer.from(randomAsU8a(Math.ceil(length / 2))).toString('hex').slice(0, length);

package/utils/index.d.ts

@@ -1,5 +1,7 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
 import { CrowdloanParaState, NetworkJson } from '@subwallet/extension-base/background/KoniTypes';
-import { AccountAuthType, AccountJson } from '@subwallet/extension-base/background/types';
+import { AccountAuthType } from '@subwallet/extension-base/background/types';
+import { AccountJson } from '@subwallet/extension-base/types';
 import { BN } from '@polkadot/util';
 export { canDerive } from './canDerive';
 export * from './mv3';
@@ -8,11 +10,13 @@ export declare const notDef: (x: any) => boolean;
 export declare const isDef: (x: any) => boolean;
 export declare const nonEmptyArr: (x: any) => boolean;
 export declare const isEmptyArray: (x: any) => boolean;
-export declare function isAccountAll(address?: string): boolean;
-export declare function reformatAddress(address: string, networkPrefix?: number, isEthereum?: boolean): string;
+/**
+ * @deprecated
+ * */
 export declare function filterAddressByNetworkKey(addresses: string[], networkKey: string, isEthereum?: boolean): string[];
-export declare function categoryAddresses(addresses: string[]): string[][];
-export declare function categoryNetworks(networks: NetworkJson[]): string[][];
+/**
+ * @deprecated
+ * */
 export declare function convertToEvmAddress(substrateAddress: string): string;
 export declare function isUrl(targetString: string): boolean;
 export declare function inJestTest(): boolean;
@@ -36,6 +40,8 @@ export declare function mergeNetworkProviders(customNetwork: NetworkJson, predef
 export declare const filterAndSortingAccountByAuthType: (accounts: AccountJson[], accountAuthType: AccountAuthType, sorting?: boolean) => AccountJson[];
 export declare function parseRawNumber(value: string): number;
 export declare function isSameAddress(address1: string, address2: string): boolean;
+export declare function isSameAddressType(address1: string, address2: string): boolean;
+export declare function isAddressAndChainCompatible(address: string, chain: _ChainInfo): boolean;
 export declare function getDomainFromUrl(url: string): string;
 export declare function waitTimeout(ms: number): Promise<void>;
 export declare const stripUrl: (url: string) => string;
@@ -45,6 +51,7 @@ export declare function wait(milliseconds: number): Promise<void>;
 export * from './account';
 export * from './array';
 export * from './asset';
+export * from './auth';
 export * from './environment';
 export * from './eth';
 export * from './fetchEvmChainInfo';