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

package/cjs/services/keyring-service/context/handlers/Json.js

@@ -0,0 +1,348 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountJsonHandler = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _keyring = require("@subwallet/keyring");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _Base = require("./Base");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class AccountJsonHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's JSON
+ * */
+class AccountJsonHandler extends _Base.AccountBaseHandler {
+  decodeAddress = (key, ignoreChecksum, ss58Format) => {
+    return _uiKeyring.keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+  };
+  encodeAddress = (key, ss58Format) => {
+    return _uiKeyring.keyring.encodeAddress(key, ss58Format);
+  };
+  validatePassword(json, password) {
+    const cryptoType = Array.isArray(json.encoding.content) ? json.encoding.content[1] : 'ed25519';
+    const encType = Array.isArray(json.encoding.type) ? json.encoding.type : [json.encoding.type];
+    const pair = (0, _keyring.createPair)({
+      toSS58: this.encodeAddress,
+      type: cryptoType
+    }, {
+      publicKey: this.decodeAddress(json.address, true)
+    }, json.meta, (0, _util.isHex)(json.encoded) ? (0, _util.hexToU8a)(json.encoded) : (0, _utilCrypto.base64Decode)(json.encoded), encType);
+
+    // unlock then lock (locking cleans secretKey, so needs to be last)
+    try {
+      pair.decodePkcs8(password);
+      pair.lock();
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+  parseInfoSingleJson(_ref) {
+    let {
+      json,
+      password
+    } = _ref;
+    const isPasswordValidated = this.validatePassword(json, password);
+    if (isPasswordValidated) {
+      try {
+        const {
+          address,
+          meta,
+          type
+        } = _uiKeyring.keyring.createFromJson(json);
+        const {
+          name
+        } = meta;
+        const account = (0, _utils.transformAccount)(address, type, meta);
+        const accountExists = this.state.checkAddressExists([address]);
+        const nameExists = this.state.checkNameExists(name);
+        // Note: Show accountName of account exists to support user to know which account is existed
+        const accountName = accountExists ? accountExists.name : account.name || account.address;
+        const proxy = {
+          id: address,
+          accountType: (0, _utils.convertAccountProxyType)(account.signMode),
+          name: accountName,
+          accounts: [account],
+          chainTypes: [account.chainType],
+          parentId: account.parentAddress,
+          suri: account.suri,
+          tokenTypes: account.tokenTypes,
+          accountActions: [],
+          isExistAccount: !!accountExists,
+          isExistName: nameExists
+        };
+        return {
+          accountProxy: proxy
+        };
+      } catch (e) {
+        console.error(e);
+        throw new Error(e.message);
+      }
+    } else {
+      throw new Error((0, _i18next.t)('Incorrect password'));
+    }
+  }
+  jsonRestoreV2(_ref2, onDone) {
+    let {
+      address,
+      file,
+      isAllowed,
+      password,
+      withMasterPassword
+    } = _ref2;
+    const isPasswordValidated = this.validatePassword(file, password);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    if (isPasswordValidated) {
+      try {
+        const _pair = _uiKeyring.keyring.createFromJson(file);
+        const exists = this.state.checkAddressExists([_pair.address]);
+        (0, _util.assert)(!exists, (0, _i18next.t)('Account already exists under the name {{name}}', {
+          replace: {
+            name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || _pair.address
+          }
+        }));
+        _uiKeyring.keyring.restoreAccount(file, password, withMasterPassword);
+        const pair = _uiKeyring.keyring.getPair(_pair.address);
+        const _name = pair.meta.name || '';
+        const nameExists = this.state.checkNameExists(_name);
+        if (nameExists) {
+          const newName = _name.concat(' - ').concat((0, _getId.generateRandomString)());
+          _uiKeyring.keyring.saveAccountMeta(pair, {
+            ...pair.meta,
+            name: newName
+          });
+        }
+        this.state.saveCurrentAccountProxyId(address, () => {
+          this.state.updateMetadataForPair();
+          this.state._addAddressToAuthList(address, isAllowed);
+          resolve([address]);
+          onDone();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    } else {
+      reject(new Error((0, _i18next.t)('Incorrect password')));
+    }
+    return promise;
+  }
+  validatedAccountsPassword(json, password) {
+    try {
+      const decoded = (0, _util.u8aToString)((0, _utilCrypto.jsonDecrypt)(json, password));
+      return JSON.parse(decoded);
+    } catch (e) {
+      return null;
+    }
+  }
+  parseInfoMultiJson(_ref3) {
+    let {
+      json,
+      password
+    } = _ref3;
+    const jsons = this.validatedAccountsPassword(json, password);
+    if (jsons) {
+      try {
+        const {
+          accountProxies,
+          modifyPairs
+        } = json;
+        const pairs = jsons.map(pair => _uiKeyring.keyring.createFromJson(pair));
+        const accountProxyMap = (0, _utils.combineAccountsWithKeyPair)(pairs, modifyPairs, accountProxies);
+        const result = Object.values(accountProxyMap).map(proxy => {
+          const rs = {
+            ...proxy,
+            isExistAccount: false,
+            isExistName: false
+          };
+          const accountExists = this.state.checkAddressExists(proxy.accounts.map(account => account.address));
+          const nameExists = this.state.checkNameExists(proxy.name);
+          rs.isExistAccount = !!accountExists;
+          rs.isExistName = nameExists;
+          rs.name = accountExists ? accountExists.name : proxy.name;
+          return rs;
+        });
+        return {
+          accountProxies: result
+        };
+      } catch (e) {
+        console.error(e);
+        throw new Error(e.message);
+      }
+    } else {
+      throw new Error((0, _i18next.t)('Incorrect password'));
+    }
+  }
+  batchRestoreV2(_ref4) {
+    let {
+      file,
+      isAllowed,
+      password,
+      proxyIds: _proxyIds
+    } = _ref4;
+    const jsons = this.validatedAccountsPassword(file, password);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    if (jsons) {
+      try {
+        const {
+          accountProxies,
+          modifyPairs
+        } = file;
+        const pairs = jsons.map(pair => _uiKeyring.keyring.createFromJson(pair));
+        const accountProxyMap = (0, _utils.combineAccountsWithKeyPair)(pairs, modifyPairs, accountProxies);
+        const rawProxyIds = _proxyIds && _proxyIds.length ? _proxyIds : Object.keys(accountProxyMap);
+        let _exists;
+        const proxiesChangeName = {};
+        const accountNameDuplicates = this.state.getDuplicateAccountNames(Object.values(accountProxyMap).filter(_ref5 => {
+          let {
+            id
+          } = _ref5;
+          return rawProxyIds.includes(id);
+        }));
+        const filteredAccountProxies = Object.fromEntries(Object.entries(accountProxyMap).filter(_ref6 => {
+          let [proxyId, accountProxy] = _ref6;
+          if (!rawProxyIds.includes(proxyId)) {
+            return false;
+          }
+          const addresses = accountProxy.accounts.map(account => account.address);
+          const exists = this.state.checkAddressExists(addresses);
+          const name = accountProxy.name;
+          if (this.state.checkNameExists(name) || accountNameDuplicates.includes(name)) {
+            proxiesChangeName[proxyId] = name.concat(' - ').concat((0, _getId.generateRandomString)());
+          }
+          _exists = exists;
+          return !exists;
+        }));
+        const addresses = Object.values(filteredAccountProxies).flatMap(proxy => proxy.accounts.map(account => account.address));
+        const proxyIds = Object.values(filteredAccountProxies).flatMap(proxy => proxy.id);
+        if (!addresses.length) {
+          if (_exists) {
+            throw new Error((0, _i18next.t)('Account already exists under the name {{name}}', {
+              replace: {
+                name: _exists.name || _exists.address || ''
+              }
+            }));
+          } else {
+            throw new Error((0, _i18next.t)('No accounts found to import'));
+          }
+        }
+        const _accountProxies = this.state.value.accountProxy;
+        const _modifyPairs = this.state.value.modifyPair;
+        const currentProxyId = this.state.value.currentAccount.proxyId;
+        const nextAccountProxyId = !proxyIds.length ? currentProxyId : proxyIds.length === 1 ? proxyIds[0] : _constants.ALL_ACCOUNT_KEY;
+        if (accountProxies) {
+          for (const proxyId of proxyIds) {
+            const accountProxy = accountProxies[proxyId];
+            if (accountProxy) {
+              if (proxiesChangeName[proxyId]) {
+                accountProxy.name = proxiesChangeName[proxyId];
+              }
+              _accountProxies[proxyId] = accountProxy;
+            }
+          }
+        }
+        if (modifyPairs) {
+          for (const [key, modifyPair] of Object.entries(modifyPairs)) {
+            if (proxyIds.includes(modifyPair.accountProxyId || '')) {
+              _modifyPairs[key] = modifyPair;
+            }
+          }
+        }
+        this.state.upsertAccountProxy(_accountProxies);
+        this.state.upsertModifyPairs(_modifyPairs);
+        _uiKeyring.keyring.restoreAccounts(file, password, addresses);
+        for (const [proxyId, accountProxy] of Object.entries(accountProxyMap)) {
+          const name = proxiesChangeName[proxyId];
+          if (name) {
+            for (const account of accountProxy.accounts) {
+              const pair = _uiKeyring.keyring.getPair(account.address);
+              _uiKeyring.keyring.saveAccountMeta(pair, {
+                ...pair.meta,
+                name
+              });
+            }
+          }
+        }
+        const successAddressList = addresses.reduce((rs, address) => {
+          try {
+            const account = _uiKeyring.keyring.getPair(address);
+            if (account) {
+              rs.push(address);
+            }
+          } catch (error) {
+            console.log(error);
+          }
+          return rs;
+        }, []);
+        this.state.saveCurrentAccountProxyId(nextAccountProxyId, () => {
+          this.state.updateMetadataForPair();
+          this.state._addAddressesToAuthList(addresses, isAllowed);
+          resolve(successAddressList);
+        });
+      } catch (error) {
+        throw new Error(error.message);
+      }
+    } else {
+      reject(new Error((0, _i18next.t)('Incorrect password')));
+    }
+    return promise;
+  }
+  async batchExportV2(request) {
+    const {
+      password,
+      proxyIds
+    } = request;
+    try {
+      if (proxyIds && !proxyIds.length) {
+        throw new Error((0, _i18next.t)('No accounts found to export'));
+      }
+      const _accountProxy = this.state.value.accountProxy;
+      const _modifyPair = this.state.value.modifyPair;
+      const _account = this.state.value.accounts;
+      const _proxyIds = proxyIds || Object.keys(_account);
+      const modifyPairs = Object.fromEntries(Object.entries(_modifyPair).filter(_ref7 => {
+        let [, modifyPair] = _ref7;
+        return _proxyIds.includes(modifyPair.accountProxyId || '');
+      }));
+      const accountProxies = Object.fromEntries(Object.entries(_accountProxy).filter(_ref8 => {
+        let [, proxy] = _ref8;
+        return _proxyIds.includes(proxy.id);
+      }));
+      const addresses = Object.values(_account).filter(account => _proxyIds.includes(account.id)).flatMap(proxy => proxy.accounts.map(account => account.address));
+      const rs = await _uiKeyring.keyring.backupAccounts(password, addresses);
+      if (Object.keys(modifyPairs).length && Object.keys(accountProxies).length) {
+        rs.accountProxies = accountProxies;
+        rs.modifyPairs = modifyPairs;
+      }
+      return {
+        exportedJson: rs
+      };
+    } catch (e) {
+      const error = e;
+      if (error.message === 'Invalid master password') {
+        throw new Error((0, _i18next.t)('Incorrect password'));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+exports.AccountJsonHandler = AccountJsonHandler;

package/cjs/services/keyring-service/context/handlers/Ledger.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountLedgerHandler = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+var _Base = require("./Base");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class AccountLedgerHandler
+ * @extends AccountBaseHandler
+ * @description Handler for Ledger account actions
+ * */
+class AccountLedgerHandler extends _Base.AccountBaseHandler {
+  /* Ledger */
+
+  /* For custom derive path */
+  async accountsCreateHardwareV2(request) {
+    const {
+      accountIndex,
+      address,
+      addressOffset,
+      genesisHash,
+      hardwareType,
+      isAllowed,
+      isEthereum,
+      isGeneric,
+      name,
+      originGenesisHash
+    } = request;
+    const exists = this.state.checkAddressExists([address]);
+    (0, _util.assert)(!exists, (0, _i18next.t)('Account already exists under the name {{name}}', {
+      replace: {
+        name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || address
+      }
+    }));
+    const baseMeta = {
+      name,
+      hardwareType,
+      accountIndex,
+      addressOffset,
+      genesisHash,
+      originGenesisHash,
+      isGeneric
+    };
+    const type = isEthereum ? 'ethereum' : 'sr25519';
+    const pair = _uiKeyring.keyring.keyring.createFromAddress(address, {
+      ...baseMeta,
+      isExternal: true,
+      isHardware: true,
+      availableGenesisHashes: isGeneric ? undefined : [genesisHash]
+    }, null, type);
+    const _address = pair.address;
+    const modifiedPairs = this.state.modifyPairs;
+    modifiedPairs[_address] = {
+      migrated: true,
+      key: _address
+    };
+    this.state.upsertModifyPairs(modifiedPairs);
+    _uiKeyring.keyring.addPair(pair, false);
+    await new Promise(resolve => {
+      this.state.saveCurrentAccountProxyId(_address, () => {
+        this.state._addAddressToAuthList(_address, isAllowed || false);
+        resolve();
+      });
+    });
+    return true;
+  }
+
+  /* For multi select */
+  async accountsCreateHardwareMultiple(_ref) {
+    let {
+      accounts
+    } = _ref;
+    const addresses = [];
+    if (!accounts.length) {
+      throw new Error((0, _i18next.t)('Can\'t find an account. Please try again'));
+    }
+    const exists = this.state.checkAddressExists(accounts.map(account => account.address));
+    (0, _util.assert)(!exists, (0, _i18next.t)('Account already exists under the name {{name}}', {
+      replace: {
+        name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || ''
+      }
+    }));
+    const slugMap = {};
+    const modifyPairs = this.state.modifyPairs;
+    const pairs = [];
+    for (const account of accounts) {
+      const {
+        accountIndex,
+        address,
+        addressOffset,
+        genesisHash,
+        hardwareType,
+        isEthereum,
+        isGeneric,
+        name,
+        originGenesisHash
+      } = account;
+      const baseMeta = {
+        name,
+        hardwareType,
+        accountIndex,
+        addressOffset,
+        genesisHash,
+        originGenesisHash,
+        isGeneric
+      };
+      const type = isEthereum ? 'ethereum' : 'sr25519';
+      const pair = _uiKeyring.keyring.keyring.createFromAddress(address, {
+        ...baseMeta,
+        isExternal: true,
+        isHardware: true,
+        availableGenesisHashes: isGeneric ? undefined : [genesisHash]
+      }, null, type);
+      if (isEthereum) {
+        slugMap.ethereum = 'ethereum';
+      } else {
+        const slug = this.state.findNetworkKeyByGenesisHash(genesisHash);
+        if (slug) {
+          slugMap[slug] = slug;
+        }
+      }
+      const _address = pair.address;
+      modifyPairs[_address] = {
+        migrated: true,
+        key: _address
+      };
+      addresses.push(_address);
+      pairs.push(pair);
+    }
+
+    // const currentAccount = this.#koniState.keyringService.context.currentAccount;
+    // const allGenesisHash = currentAccount?.allGenesisHash || undefined;
+
+    this.state.upsertModifyPairs(modifyPairs);
+    for (const pair of pairs) {
+      _uiKeyring.keyring.addPair(pair, false);
+    }
+    await new Promise(resolve => {
+      this.state._addAddressesToAuthList(addresses, true);
+      resolve();
+    });
+    if (addresses.length <= 1) {
+      this.state.saveCurrentAccountProxyId(addresses[0]);
+    } else {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    }
+    if (Object.keys(slugMap).length) {
+      for (const chainSlug of Object.keys(slugMap)) {
+        this.state.enableChain(chainSlug);
+      }
+    }
+    return true;
+  }
+
+  /* Ledger */
+}
+exports.AccountLedgerHandler = AccountLedgerHandler;