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

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

@@ -0,0 +1,377 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountDeriveHandler = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _types2 = require("@subwallet/keyring/types");
+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
+
+const validDeriveKeypairTypes = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes, 'ton'];
+
+/**
+ * @class AccountDeriveHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account derivation
+ * */
+class AccountDeriveHandler extends _Base.AccountBaseHandler {
+  /* Derive */
+
+  /**
+   * @func derivationCreateMultiple
+   * @desc Derive multi account
+   * @todo Must update before re-use
+   * @deprecated
+   */
+  derivationCreateMultiple(_ref) {
+    let {
+      isAllowed,
+      items,
+      parentAddress
+    } = _ref;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const createChild = _ref2 => {
+      let {
+        name,
+        suri
+      } = _ref2;
+      const meta = {
+        name: name,
+        parentAddress
+      };
+      if (isEvm) {
+        let index = 0;
+        try {
+          const reg = /^\d+$/;
+          const path = suri.split('//')[1];
+          if (reg.test(path)) {
+            index = parseInt(path);
+          }
+        } catch (e) {}
+        if (!index) {
+          throw new _types.SWDeriveError(_types.DeriveErrorType.INVALID_DERIVATION_PATH);
+        }
+        meta.suri = `//${index}`;
+        return parentPair.evm.derive(index, meta);
+      } else {
+        meta.suri = suri;
+        return parentPair.substrate.derive(suri, meta);
+      }
+    };
+    const result = [];
+    for (const item of items) {
+      try {
+        const childPair = createChild(item);
+        const address = childPair.address;
+        _uiKeyring.keyring.addPair(childPair, true);
+        this.state._addAddressToAuthList(address, isAllowed);
+        result.push(childPair);
+      } catch (e) {
+        console.log(e);
+      }
+    }
+    if (result.length === 1) {
+      this.state.saveCurrentAccountProxyId(result[0].address);
+    } else {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    }
+    return true;
+  }
+
+  /**
+   * @func getListDeriveAccounts
+   * @desc Get a derivation account list.
+   * @todo Must update before re-use
+   * @deprecated
+   */
+  getListDeriveAccounts(_ref3) {
+    let {
+      limit,
+      page,
+      parentAddress
+    } = _ref3;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const start = (page - 1) * limit + (isEvm ? 1 : 0);
+    const end = start + limit;
+    const result = [];
+    for (let i = start; i < end; i++) {
+      const suri = `//${i}`;
+      const pair = isEvm ? parentPair.evm.derive(i, {}) : parentPair.substrate.derive(suri, {});
+      result.push({
+        address: pair.address,
+        suri: suri
+      });
+    }
+    return {
+      result: result
+    };
+  }
+
+  /* Validate derivation path */
+  validateDerivePath(_ref4) {
+    let {
+      proxyId,
+      suri
+    } = _ref4;
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    let type;
+    if (!isUnified) {
+      try {
+        const pair = _uiKeyring.keyring.getPair(proxyId);
+        type = pair.type;
+      } catch (e) {
+        throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+      }
+    }
+    const derivationInfo = (0, _utils.validateDerivationPath)(suri, type);
+    const account = this.state.accounts[proxyId];
+    if (derivationInfo) {
+      const accountTypes = account.accounts.map(acc => acc.type);
+
+      /* Minimum depth is 1 */
+      if (derivationInfo.depth < 1) {
+        return {
+          info: undefined,
+          error: new _types.SWDeriveError(_types.DeriveErrorType.MIN_DERIVATION_DEPTH).toJSON()
+        };
+      }
+
+      /* Maximum depth is 2 */
+      if (derivationInfo.depth > 2) {
+        return {
+          info: undefined,
+          error: new _types.SWDeriveError(_types.DeriveErrorType.MAX_DERIVATION_DEPTH).toJSON()
+        };
+      }
+      if (isUnified && derivationInfo.type === 'unified') {
+        return {
+          info: derivationInfo
+        };
+      } else if (accountTypes.includes(derivationInfo.type)) {
+        return {
+          info: derivationInfo
+        };
+      } else {
+        return {
+          info: undefined,
+          error: new _types.SWDeriveError(_types.DeriveErrorType.INVALID_DERIVATION_TYPE).toJSON()
+        };
+      }
+    } else {
+      return {
+        info: undefined,
+        error: new _types.SWDeriveError(_types.DeriveErrorType.INVALID_DERIVATION_PATH).toJSON()
+      };
+    }
+  }
+  getDeriveSuggestion(_ref5) {
+    let {
+      proxyId
+    } = _ref5;
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    let rs;
+    if (isUnified) {
+      rs = (0, _utils.findUnifiedNextDerive)(proxyId, this.state.accounts);
+    } else {
+      let pair;
+      try {
+        pair = _uiKeyring.keyring.getPair(proxyId);
+      } catch (e) {}
+      if (!pair) {
+        return {
+          proxyId,
+          error: new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NOT_FOUND).toJSON()
+        };
+      }
+      if (!validDeriveKeypairTypes.includes(pair.type)) {
+        return {
+          proxyId,
+          error: new _types.SWDeriveError(_types.DeriveErrorType.INVALID_ACCOUNT_TYPE).toJSON()
+        };
+      }
+      rs = (0, _utils.findSoloNextDerive)(proxyId);
+    }
+    return {
+      proxyId,
+      info: {
+        suri: rs.suri,
+        derivationPath: rs.derivationPath
+      }
+    };
+  }
+
+  /**
+   * Derive account proxy
+   *  */
+  derivationAccountProxyCreate(request) {
+    const {
+      name,
+      proxyId: deriveId,
+      suri
+    } = request;
+    const isUnified = this.state.isUnifiedAccount(deriveId);
+    const parentProxyId = this.state.belongUnifiedAccount(deriveId) || deriveId;
+    const rootId = this.state.value.accounts[parentProxyId].parentId || parentProxyId;
+    const rootProxyId = this.state.belongUnifiedAccount(rootId) || rootId;
+    const nameExists = this.state.checkNameExists(name);
+    if (nameExists) {
+      throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
+    }
+    const validateRs = this.validateDerivePath({
+      proxyId: deriveId,
+      suri
+    });
+    if (!validateRs.info) {
+      if (validateRs.error) {
+        throw Error(validateRs.error.message);
+      } else {
+        throw new _types.SWDeriveError(_types.DeriveErrorType.INVALID_DERIVATION_PATH);
+      }
+    }
+    const derivationInfo = validateRs.info;
+    const pairs = [];
+    const modifyPairs = this.state.modifyPairs;
+    let childAccountProxy;
+    let proxyId;
+
+    /**
+     * Can change to deep find root pair
+     * Now all root pair is in the first level, so don't need to deep find
+     */
+    const findRootPair = account => {
+      const deriveInfo = (0, _utils.getSoloDerivationInfo)(account.type, account);
+      const needChangeRoot = deriveInfo.depth > 0;
+      let rootPair;
+      if (needChangeRoot) {
+        try {
+          rootPair = _uiKeyring.keyring.getPair(account.parentAddress || '');
+        } catch (e) {}
+      } else {
+        try {
+          rootPair = _uiKeyring.keyring.getPair(account.address);
+        } catch (e) {}
+      }
+      return rootPair;
+    };
+    if (derivationInfo.type === 'unified') {
+      const accountProxy = this.state.value.accounts[deriveId];
+      if (!accountProxy) {
+        throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+      }
+      const accounts = accountProxy.accounts;
+      proxyId = (0, _utils.createAccountProxyId)(rootProxyId, suri);
+      for (const account of accounts) {
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new _types.SWDeriveError(_types.DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const derivationPath = (0, _utils.parseUnifiedSuriToDerivationPath)(derivationInfo.suri, account.type);
+        const childPair = (0, _utils.derivePair)(rootPair, request.name, derivationInfo.suri, derivationPath);
+        const address = childPair.address;
+        modifyPairs[address] = {
+          accountProxyId: proxyId,
+          migrated: true,
+          key: address
+        };
+        pairs.push(childPair);
+      }
+      childAccountProxy = {
+        id: proxyId,
+        name,
+        parentId: rootProxyId,
+        suri: suri
+      };
+    } else {
+      const type = derivationInfo.type;
+      if (isUnified) {
+        const accountProxy = this.state.value.accounts[deriveId];
+        const account = accountProxy.accounts.find(account => account.type === type);
+        if (!account) {
+          throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+        }
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new _types.SWDeriveError(_types.DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const childPair = (0, _utils.derivePair)(rootPair, request.name, derivationInfo.suri, derivationInfo.derivationPath);
+        const address = childPair.address;
+        proxyId = address;
+        modifyPairs[address] = {
+          accountProxyId: proxyId,
+          migrated: true,
+          key: address
+        };
+        childAccountProxy = {
+          id: proxyId,
+          name,
+          parentId: rootProxyId,
+          suri: suri
+        };
+        pairs.push(childPair);
+      } else {
+        const account = this.state.value.accounts[deriveId].accounts[0];
+        if (!account) {
+          throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+        }
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new _types.SWDeriveError(_types.DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const childPair = (0, _utils.derivePair)(rootPair, request.name, derivationInfo.suri, derivationInfo.derivationPath);
+        const address = childPair.address;
+        proxyId = address;
+        if (rootProxyId) {
+          modifyPairs[address] = {
+            accountProxyId: proxyId,
+            migrated: true,
+            key: address
+          };
+          childAccountProxy = {
+            id: proxyId,
+            name,
+            parentId: rootProxyId,
+            suri: suri
+          };
+        }
+        pairs.push(childPair);
+      }
+    }
+    const addresses = pairs.map(pair => pair.address);
+    const exists = this.state.checkAddressExists(addresses);
+    (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) || ''
+      }
+    }));
+    childAccountProxy && this.state.upsertAccountProxyByKey(childAccountProxy);
+    this.state.upsertModifyPairs(modifyPairs);
+    for (const childPair of pairs) {
+      _uiKeyring.keyring.addPair(childPair, true);
+    }
+    this.state.updateMetadataForPair();
+    this.state.updateMetadataForProxy();
+    this.state.saveCurrentAccountProxyId(proxyId, () => {
+      this.state._addAddressesToAuthList(pairs.map(pair => pair.address), true);
+    });
+    return true;
+  }
+
+  /* Derive */
+}
+exports.AccountDeriveHandler = AccountDeriveHandler;

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountInjectHandler = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _util = require("@polkadot/util");
+var _Base = require("./Base");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class AccountInjectHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account inject actions
+ * */
+class AccountInjectHandler extends _Base.AccountBaseHandler {
+  /* Inject */
+
+  addInjectAccounts(accounts) {
+    _uiKeyring.keyring.addInjects(accounts.map(account => {
+      const name = account.meta.name || (0, _util.stringShorten)(account.address);
+
+      // TODO: Add if need
+      // name = name.concat(' (', account.meta.source, ')');
+
+      return {
+        ...account,
+        meta: {
+          ...account.meta,
+          name: name
+        }
+      };
+    }));
+    const currentAddress = this.state.currentAccount.proxyId;
+    const afterAccounts = {};
+    Object.keys(this.state.accounts).forEach(adr => {
+      afterAccounts[adr] = true;
+    });
+    accounts.forEach(value => {
+      afterAccounts[value.address] = true;
+    });
+    if (Object.keys(afterAccounts).length === 1) {
+      this.state.saveCurrentAccountProxyId(Object.keys(afterAccounts)[0]);
+    } else if (Object.keys(afterAccounts).indexOf(currentAddress) === -1) {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    }
+    if (!this.state.injected) {
+      this.parentService.eventInjectReady();
+      this.state.setInjected(true);
+    }
+  }
+  removeInjectAccounts(_addresses) {
+    const addresses = _addresses.map(address => {
+      try {
+        return _uiKeyring.keyring.getPair(address).address;
+      } catch (error) {
+        return address;
+      }
+    });
+    const currentAddress = this.state.currentAccount.proxyId;
+    const afterAccounts = Object.keys(this.state.accounts).filter(address => addresses.indexOf(address) < 0);
+    if (afterAccounts.length === 1) {
+      this.state.saveCurrentAccountProxyId(afterAccounts[0]);
+    } else if (addresses.indexOf(currentAddress) === -1) {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    }
+    _uiKeyring.keyring.removeInjects(addresses);
+  }
+
+  /* Inject */
+}
+exports.AccountInjectHandler = AccountInjectHandler;