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

package/cjs/utils/account/transform.js

@@ -0,0 +1,566 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformAddresses = exports.transformAddress = exports.transformAccounts = exports.transformAccount = exports.singleAddressToAccount = exports.pairToAccount = exports.getAccountTransactionActions = exports.getAccountTokenTypes = exports.getAccountSignMode = exports.getAccountChainType = exports.getAccountActions = exports.createAccountProxyId = exports.convertAccountProxyType = exports.combineAllAccountProxy = exports.combineAccountsWithSubjectInfo = exports.combineAccountsWithKeyPair = exports._combineAccounts = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types2 = require("@subwallet/extension-base/types");
+var _keyring = require("@subwallet/keyring");
+var _types3 = require("@subwallet/keyring/types");
+var _utils2 = require("@subwallet/keyring/utils");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _derive = require("./derive");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const createAccountProxyId = (_suri, derivationPath) => {
+  let data = _suri;
+  if ((0, _utilCrypto.mnemonicValidate)(_suri)) {
+    const entropy = (0, _utilCrypto.mnemonicToEntropy)(_suri);
+    data = (0, _util.u8aToHex)(entropy);
+    if (derivationPath) {
+      data = (0, _utilCrypto.blake2AsHex)(data, 256);
+    }
+  } else if ((0, _utils2.tonMnemonicValidate)(_suri)) {
+    const entropy = (0, _keyring.tonMnemonicToEntropy)(_suri);
+    data = (0, _util.u8aToHex)(entropy);
+    if (derivationPath) {
+      data = (0, _utilCrypto.blake2AsHex)(data, 256);
+    }
+  }
+  if (derivationPath) {
+    data = (0, _util.hexStripPrefix)(data).concat(derivationPath);
+  }
+  return (0, _utilCrypto.blake2AsHex)(data, 256);
+};
+exports.createAccountProxyId = createAccountProxyId;
+const getAccountChainType = type => {
+  return type ? _types3.EthereumKeypairTypes.includes(type) ? _types2.AccountChainType.ETHEREUM : _types3.TonKeypairTypes.includes(type) ? _types2.AccountChainType.TON : _types3.BitcoinKeypairTypes.includes(type) ? _types2.AccountChainType.BITCOIN : _types2.AccountChainType.SUBSTRATE : _types2.AccountChainType.SUBSTRATE;
+};
+exports.getAccountChainType = getAccountChainType;
+const getAccountSignMode = (address, _meta) => {
+  const meta = _meta;
+  if (!address || !meta) {
+    return _types2.AccountSignMode.UNKNOWN;
+  } else {
+    if (address === _constants.ALL_ACCOUNT_KEY) {
+      return _types2.AccountSignMode.ALL_ACCOUNT;
+    } else {
+      if (meta.isInjected) {
+        return _types2.AccountSignMode.INJECTED;
+      }
+      if (meta.isExternal) {
+        if (meta.isHardware) {
+          if (meta.isGeneric) {
+            return _types2.AccountSignMode.GENERIC_LEDGER;
+          } else {
+            return _types2.AccountSignMode.LEGACY_LEDGER;
+          }
+        } else if (meta.isReadOnly) {
+          return _types2.AccountSignMode.READ_ONLY;
+        } else {
+          return _types2.AccountSignMode.QR;
+        }
+      } else {
+        return _types2.AccountSignMode.PASSWORD;
+      }
+    }
+  }
+};
+exports.getAccountSignMode = getAccountSignMode;
+const getAccountActions = (signMode, networkType, type, _meta, parentAccount) => {
+  const result = [];
+  const meta = _meta;
+
+  // JSON
+  if (signMode === _types2.AccountSignMode.PASSWORD) {
+    result.push(_types2.AccountActions.EXPORT_JSON);
+  }
+
+  // Mnemonic
+  if (meta && meta.isMasterAccount) {
+    result.push(_types2.AccountActions.EXPORT_MNEMONIC);
+  }
+
+  // Private key
+  if (signMode === _types2.AccountSignMode.PASSWORD) {
+    if (networkType === _types2.AccountChainType.ETHEREUM || networkType === _types2.AccountChainType.TON) {
+      result.push(_types2.AccountActions.EXPORT_PRIVATE_KEY);
+    }
+  }
+
+  // QR
+  if (signMode === _types2.AccountSignMode.PASSWORD) {
+    if (networkType === _types2.AccountChainType.ETHEREUM || networkType === _types2.AccountChainType.SUBSTRATE) {
+      result.push(_types2.AccountActions.EXPORT_QR);
+    }
+  }
+
+  // Derive
+  if (signMode === _types2.AccountSignMode.PASSWORD) {
+    const deriveInfo = (0, _derive.getSoloDerivationInfo)(type, meta);
+    if (networkType === _types2.AccountChainType.SUBSTRATE) {
+      if (deriveInfo.depth === 0) {
+        result.push(_types2.AccountActions.DERIVE);
+      } else if (deriveInfo.depth === 1) {
+        if (parentAccount && parentAccount.accountActions.includes(_types2.AccountActions.DERIVE)) {
+          result.push(_types2.AccountActions.DERIVE);
+        }
+      }
+    } else if (type !== 'ton-native') {
+      if (deriveInfo.depth === 0) {
+        if (meta && meta.isMasterAccount) {
+          result.push(_types2.AccountActions.DERIVE);
+        }
+      } else if (deriveInfo.depth === 1) {
+        if (parentAccount && parentAccount.accountActions.includes(_types2.AccountActions.DERIVE)) {
+          result.push(_types2.AccountActions.DERIVE);
+        }
+      }
+    }
+  }
+
+  // Ton change wallet contract version
+  if (networkType === _types2.AccountChainType.TON && signMode !== _types2.AccountSignMode.READ_ONLY) {
+    result.push(_types2.AccountActions.TON_CHANGE_WALLET_CONTRACT_VERSION);
+  }
+  return result;
+};
+exports.getAccountActions = getAccountActions;
+const BASE_TRANSFER_ACTIONS = [_KoniTypes.ExtrinsicType.TRANSFER_BALANCE, _KoniTypes.ExtrinsicType.TRANSFER_TOKEN];
+const NATIVE_STAKE_ACTIONS = [_KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.STAKING_UNBOND, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
+// ExtrinsicType.STAKING_COMPOUNDING,
+// ExtrinsicType.STAKING_CANCEL_COMPOUNDING,
+_KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE];
+const POOL_STAKE_ACTIONS = [_KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, _KoniTypes.ExtrinsicType.STAKING_POOL_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD, _KoniTypes.ExtrinsicType.JOIN_YIELD_POOL];
+const EARN_VDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_VDOT, _KoniTypes.ExtrinsicType.REDEEM_VDOT, _KoniTypes.ExtrinsicType.UNSTAKE_VDOT];
+const EARN_LDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_LDOT, _KoniTypes.ExtrinsicType.REDEEM_LDOT, _KoniTypes.ExtrinsicType.UNSTAKE_LDOT];
+const EARN_SDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_SDOT, _KoniTypes.ExtrinsicType.REDEEM_SDOT, _KoniTypes.ExtrinsicType.UNSTAKE_SDOT];
+const EARN_QDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_QDOT, _KoniTypes.ExtrinsicType.REDEEM_QDOT, _KoniTypes.ExtrinsicType.UNSTAKE_QDOT];
+const EARN_STDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_STDOT, _KoniTypes.ExtrinsicType.REDEEM_STDOT, _KoniTypes.ExtrinsicType.UNSTAKE_STDOT];
+const EARN_VMANTA_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_VMANTA, _KoniTypes.ExtrinsicType.REDEEM_VMANTA, _KoniTypes.ExtrinsicType.UNSTAKE_VMANTA];
+const EVM_ACTIONS = [_KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL, _KoniTypes.ExtrinsicType.EVM_EXECUTE];
+const OTHER_ACTIONS = [_KoniTypes.ExtrinsicType.TRANSFER_XCM, _KoniTypes.ExtrinsicType.SEND_NFT, _KoniTypes.ExtrinsicType.SWAP, _KoniTypes.ExtrinsicType.CROWDLOAN];
+const getAccountTransactionActions = (signMode, networkType, type, _meta, _specialNetwork) => {
+  if ([_types2.AccountSignMode.PASSWORD, _types2.AccountSignMode.INJECTED].includes(signMode)) {
+    switch (networkType) {
+      case _types2.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 _types2.AccountChainType.ETHEREUM:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...EVM_ACTIONS];
+      case _types2.AccountChainType.TON:
+        return [...BASE_TRANSFER_ACTIONS];
+    }
+  } else if (signMode === _types2.AccountSignMode.QR) {
+    switch (networkType) {
+      case _types2.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 _types2.AccountChainType.ETHEREUM:
+        return [...(_constants.isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
+      case _types2.AccountChainType.TON:
+        return [];
+    }
+  } else if (signMode === _types2.AccountSignMode.GENERIC_LEDGER) {
+    switch (networkType) {
+      case _types2.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 _types2.AccountChainType.ETHEREUM:
+        return [...BASE_TRANSFER_ACTIONS, ...EARN_STDOT_ACTIONS, ...EVM_ACTIONS, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
+        // For liquid staking
+        _KoniTypes.ExtrinsicType.SEND_NFT, _KoniTypes.ExtrinsicType.SWAP];
+      case _types2.AccountChainType.TON:
+        return [...BASE_TRANSFER_ACTIONS];
+    }
+  } else if (signMode === _types2.AccountSignMode.LEGACY_LEDGER) {
+    // Only for Substrate
+    const result = [];
+    const specialNetwork = _specialNetwork || '';
+    result.push(...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, _KoniTypes.ExtrinsicType.SWAP, _KoniTypes.ExtrinsicType.CROWDLOAN);
+
+    // NFT
+    if (!['astar', 'avail_mainnet'].includes(specialNetwork)) {
+      result.push(_KoniTypes.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(_KoniTypes.ExtrinsicType.TRANSFER_XCM);
+    }
+    return result;
+  }
+  return [];
+};
+exports.getAccountTransactionActions = getAccountTransactionActions;
+const getAccountTokenTypes = type => {
+  switch (type) {
+    case 'ethereum':
+      return [_types._AssetType.NATIVE, _types._AssetType.LOCAL, _types._AssetType.ERC20, _types._AssetType.ERC721];
+    case 'sr25519':
+    case 'ed25519':
+    case 'ecdsa':
+      return [_types._AssetType.NATIVE, _types._AssetType.LOCAL, _types._AssetType.PSP22, _types._AssetType.PSP34, _types._AssetType.GRC20, _types._AssetType.ERC721, _types._AssetType.VFT];
+    case 'ton':
+    case 'ton-native':
+      return [_types._AssetType.NATIVE, _types._AssetType.TEP74];
+    case 'bitcoin-44':
+    case 'bittest-44':
+    case 'bitcoin-84':
+    case 'bittest-84':
+      return [_types._AssetType.NATIVE];
+    case 'bitcoin-86':
+    case 'bittest-86':
+      return [_types._AssetType.NATIVE, _types._AssetType.RUNE, _types._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.
+ */
+exports.getAccountTokenTypes = getAccountTokenTypes;
+const transformAccount = (address, _type, meta, chainInfoMap, parentAccount) => {
+  const signMode = getAccountSignMode(address, meta);
+  const type = _type || (0, _keyring.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 === _types2.AccountSignMode.LEGACY_LEDGER && genesisHash) {
+    const chainInfo = Object.values(chainInfoMap).find(info => (0, _utils._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
+  };
+};
+exports.transformAccount = transformAccount;
+const singleAddressToAccount = (_ref, chainInfoMap, parentAccount) => {
+  let {
+    json: {
+      address,
+      meta
+    },
+    type
+  } = _ref;
+  return transformAccount(address, type, meta, chainInfoMap, parentAccount);
+};
+exports.singleAddressToAccount = singleAddressToAccount;
+const pairToAccount = (_ref2, chainInfoMap, parentAccount) => {
+  let {
+    address,
+    meta,
+    type
+  } = _ref2;
+  return transformAccount(address, type, meta, chainInfoMap, parentAccount);
+};
+exports.pairToAccount = pairToAccount;
+const transformAccounts = accounts => Object.values(accounts).map(data => singleAddressToAccount(data));
+exports.transformAccounts = transformAccounts;
+const transformAddress = (address, meta) => {
+  const type = (0, _keyring.getKeypairTypeByAddress)(address);
+  const chainType = getAccountChainType(type);
+  return {
+    address,
+    ...meta,
+    chainType
+  };
+};
+exports.transformAddress = transformAddress;
+const transformAddresses = addresses => Object.values(addresses).map(_ref3 => {
+  let {
+    json: {
+      address,
+      meta
+    }
+  } = _ref3;
+  return transformAddress(address, meta);
+});
+exports.transformAddresses = transformAddresses;
+const convertAccountProxyType = accountSignMode => {
+  switch (accountSignMode) {
+    case _types2.AccountSignMode.GENERIC_LEDGER:
+    case _types2.AccountSignMode.LEGACY_LEDGER:
+      return _types2.AccountProxyType.LEDGER;
+    case _types2.AccountSignMode.QR:
+      return _types2.AccountProxyType.QR;
+    case _types2.AccountSignMode.READ_ONLY:
+      return _types2.AccountProxyType.READ_ONLY;
+    case _types2.AccountSignMode.INJECTED:
+      return _types2.AccountProxyType.INJECTED;
+    case _types2.AccountSignMode.PASSWORD:
+      return _types2.AccountProxyType.SOLO;
+    case _types2.AccountSignMode.ALL_ACCOUNT:
+      return _types2.AccountProxyType.ALL_ACCOUNT;
+    case _types2.AccountSignMode.UNKNOWN:
+      return _types2.AccountProxyType.UNKNOWN;
+  }
+  return _types2.AccountProxyType.UNKNOWN;
+};
+exports.convertAccountProxyType = convertAccountProxyType;
+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(_ref4 => {
+    let [key, value] = _ref4;
+    let accountType = _types2.AccountProxyType.UNKNOWN;
+    let chainTypes = [];
+    let tokenTypes = [];
+    let accountActions = [];
+    let specialChain;
+    if (value.accounts.length > 1) {
+      accountType = _types2.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(_types2.AccountActions.EXPORT_MNEMONIC))) {
+        accountActions.push(_types2.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(_types2.AccountActions.DERIVE))) {
+        accountActions.push(_types2.AccountActions.DERIVE);
+      }
+
+      // Ton change wallet contract version
+      if (value.accounts.some(account => account.accountActions.includes(_types2.AccountActions.TON_CHANGE_WALLET_CONTRACT_VERSION))) {
+        accountActions.push(_types2.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 === _types2.AccountChainType.TON) {
+        accountActions = accountActions.filter(action => action !== _types2.AccountActions.DERIVE);
+      }
+      switch (account.signMode) {
+        case _types2.AccountSignMode.GENERIC_LEDGER:
+        case _types2.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
+ * */
+exports._combineAccounts = _combineAccounts;
+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);
+};
+exports.combineAccountsWithSubjectInfo = combineAccountsWithSubjectInfo;
+const combineAccountsWithKeyPair = (pairs, modifyPairs, accountProxies, chainInfoMap) => {
+  const accounts = Object.values(pairs).map(data => pairToAccount(data, chainInfoMap));
+  return _combineAccounts(accounts, modifyPairs || {}, accountProxies || {});
+};
+exports.combineAccountsWithKeyPair = combineAccountsWithKeyPair;
+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: _constants.ALL_ACCOUNT_KEY,
+    name: 'All',
+    accounts: [],
+    accountActions: [],
+    accountType: _types2.AccountProxyType.ALL_ACCOUNT,
+    chainTypes: Array.from(chainTypes),
+    tokenTypes: Array.from(tokenTypes),
+    specialChain
+  };
+};
+exports.combineAllAccountProxy = combineAllAccountProxy;

package/cjs/utils/auth.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAddressValidWithAuthType = void 0;
+var _keyring = require("@subwallet/keyring");
+var _types = require("@subwallet/keyring/types");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const isAddressValidWithAuthType = (address, accountAuthTypes) => {
+  const keypairType = (0, _keyring.getKeypairTypeByAddress)(address);
+  const validTypes = {
+    evm: _types.EthereumKeypairTypes,
+    substrate: _types.SubstrateKeypairTypes,
+    ton: _types.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;
+// };
+exports.isAddressValidWithAuthType = isAddressValidWithAuthType;

package/cjs/utils/getId.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.generateRandomString = void 0;
 exports.getId = getId;
+var _utilCrypto = require("@polkadot/util-crypto");
 var _defaults = require("../defaults");
 // Copyright 2019-2022 @polkadot/extension authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -11,4 +13,9 @@ var _defaults = require("../defaults");
 let counter = 0;
 function getId() {
   return `${_defaults.ID_PREFIX}.${Date.now()}.${++counter}`;
-}
+}
+const generateRandomString = function () {
+  let length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 6;
+  return Buffer.from((0, _utilCrypto.randomAsU8a)(Math.ceil(length / 2))).toString('hex').slice(0, length);
+};
+exports.generateRandomString = generateRandomString;