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

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

@@ -0,0 +1,310 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountSecretHandler = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _types = require("@subwallet/extension-base/types");
+var _keyring = require("@subwallet/keyring");
+var _decode = require("@subwallet/keyring/pair/decode");
+var _types2 = require("@subwallet/keyring/types");
+var _uiKeyring = _interopRequireDefault(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 AccountSecretHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+class AccountSecretHandler extends _Base.AccountBaseHandler {
+  /* Add QR-signer, read-only */
+  async accountsCreateExternalV2(request) {
+    const {
+      address,
+      isAllowed,
+      isReadOnly,
+      name
+    } = request;
+    const type = (0, _keyring.getKeypairTypeByAddress)(address);
+    try {
+      try {
+        const exists = _uiKeyring.default.getPair(address);
+        if (exists) {
+          if (exists.type === type) {
+            return [{
+              code: _KoniTypes.AccountExternalErrorCode.INVALID_ADDRESS,
+              message: (0, _i18next.t)('Account exists')
+            }];
+          }
+        }
+      } catch (e) {}
+      const nameExists = this.state.checkNameExists(name);
+      if (nameExists) {
+        throw Error((0, _i18next.t)('Account name already exists'));
+      }
+      const meta = {
+        name,
+        isExternal: true,
+        isReadOnly,
+        genesisHash: ''
+      };
+      if ([..._types2.BitcoinKeypairTypes, ..._types2.TonKeypairTypes].includes(type) && isReadOnly) {
+        meta.noPublicKey = true;
+      }
+      const result = _uiKeyring.default.keyring.addFromAddress(address, meta, null, type);
+      _uiKeyring.default.saveAccount(result);
+      const _address = result.address;
+      const modifiedPairs = this.state.modifyPairs;
+      modifiedPairs[_address] = {
+        migrated: true,
+        key: _address
+      };
+      this.state.upsertModifyPairs(modifiedPairs);
+      await new Promise(resolve => {
+        this.state.saveCurrentAccountProxyId(_address, () => {
+          this.state._addAddressToAuthList(_address, isAllowed);
+          resolve();
+        });
+      });
+      return [];
+    } catch (e) {
+      return [{
+        code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+
+  /* Import ethereum account with the private key  */
+  _checkValidatePrivateKey(_ref) {
+    let {
+      chainType,
+      privateKey
+    } = _ref;
+    let autoAddPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const {
+      phrase
+    } = (0, _utilCrypto.keyExtractSuri)(privateKey);
+    const rs = {
+      autoAddPrefix: autoAddPrefix,
+      addressMap: {}
+    };
+    const types = [];
+    if (chainType) {
+      switch (chainType) {
+        case _types.AccountChainType.ETHEREUM:
+          types.push('ethereum');
+          break;
+        case _types.AccountChainType.TON:
+          types.push('ton');
+          break;
+      }
+    } else {
+      if ((0, _util.isHex)(phrase, 256)) {
+        types.push('ethereum');
+      } else if ((0, _util.isHex)(phrase, 512)) {
+        types.push('ton');
+      }
+    }
+    types.forEach(type => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      rs.addressMap[type] = '';
+    });
+    if (types.length) {
+      types && types.forEach(type => {
+        rs.addressMap[type] = _uiKeyring.default.createFromUri(privateKey, {}, type).address;
+      });
+      rs.keyTypes = types;
+    } else {
+      rs.autoAddPrefix = false;
+      (0, _util.assert)(false, (0, _i18next.t)('Invalid private key'));
+    }
+    const exists = this.state.checkAddressExists(Object.values(rs.addressMap));
+    (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) || ''
+      }
+    }));
+    return rs;
+  }
+  privateKeyValidateV2(_ref2) {
+    let {
+      chainType,
+      privateKey
+    } = _ref2;
+    const isHex = privateKey.startsWith('0x');
+    if (isHex) {
+      return this._checkValidatePrivateKey({
+        chainType,
+        privateKey
+      });
+    } else {
+      return this._checkValidatePrivateKey({
+        chainType,
+        privateKey: `0x${privateKey}`
+      }, true);
+    }
+  }
+  async accountsCreateWithSecret(request) {
+    const {
+      isAllow,
+      isEthereum,
+      name,
+      publicKey,
+      secretKey
+    } = request;
+    try {
+      let keyringPair = null;
+      if (isEthereum) {
+        const _secret = (0, _util.hexStripPrefix)(secretKey);
+        if (_secret.length === 64) {
+          const suri = `0x${_secret}`;
+          const {
+            phrase
+          } = (0, _utilCrypto.keyExtractSuri)(suri);
+          if ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
+            const type = 'ethereum';
+            keyringPair = _uiKeyring.default.createFromUri(suri, {
+              name: name
+            }, type);
+          }
+        }
+      } else {
+        keyringPair = _uiKeyring.default.keyring.createFromPair({
+          publicKey: (0, _util.hexToU8a)(publicKey),
+          secretKey: (0, _util.hexToU8a)(secretKey)
+        }, {
+          name
+        }, 'sr25519');
+      }
+      if (!keyringPair) {
+        return {
+          success: false,
+          errors: [{
+            code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+            message: (0, _i18next.t)('Cannot create account')
+          }]
+        };
+      }
+      const _address = keyringPair.address;
+      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) || ''
+        }
+      }));
+      const nameExists = this.state.checkNameExists(name);
+      (0, _util.assert)(!nameExists, new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NAME_EXISTED).message);
+      const modifyPairs = this.state.modifyPairs;
+      modifyPairs[_address] = {
+        migrated: true,
+        key: _address
+      };
+      this.state.upsertModifyPairs(modifyPairs);
+      _uiKeyring.default.addPair(keyringPair, true);
+      await new Promise(resolve => {
+        this.state.saveCurrentAccountProxyId(_address, () => {
+          this.state._addAddressToAuthList(_address, isAllow);
+          resolve();
+        });
+      });
+      return {
+        errors: [],
+        success: true
+      };
+    } catch (e) {
+      return {
+        success: false,
+        errors: [{
+          code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+          message: e.message
+        }]
+      };
+    }
+  }
+  checkPublicAndSecretKey(_ref3) {
+    let {
+      publicKey,
+      secretKey
+    } = _ref3;
+    let response = {
+      address: '',
+      isValid: true,
+      isEthereum: false
+    };
+    try {
+      const _secret = (0, _util.hexStripPrefix)(secretKey);
+      if (_secret.length === 64) {
+        const suri = `0x${_secret}`;
+        const {
+          phrase
+        } = (0, _utilCrypto.keyExtractSuri)(suri);
+        if ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
+          const type = 'ethereum';
+          const address = _uiKeyring.default.createFromUri(suri, {}, type).address;
+          response = {
+            address: address,
+            isValid: true,
+            isEthereum: true
+          };
+        } else {
+          response = {
+            address: '',
+            isValid: false,
+            isEthereum: true
+          };
+        }
+      } else {
+        const keyPair = _uiKeyring.default.keyring.createFromPair({
+          publicKey: (0, _util.hexToU8a)(publicKey),
+          secretKey: (0, _util.hexToU8a)(secretKey)
+        }, {}, 'sr25519');
+        response = {
+          address: keyPair.address,
+          isValid: true,
+          isEthereum: false
+        };
+      }
+    } catch (e) {
+      console.error(e);
+      return {
+        address: '',
+        isValid: false,
+        isEthereum: false,
+        errorMessage: (0, _i18next.t)(e.message)
+      };
+    }
+    if (response.isValid) {
+      const exists = this.state.checkAddressExists([response.address]);
+      if (exists) {
+        response.errorMessage = (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) || ''
+          }
+        });
+        response.isValid = false;
+      }
+    }
+    return response;
+  }
+  accountExportPrivateKey(request) {
+    const {
+      address,
+      password
+    } = request;
+    const exportedJson = _uiKeyring.default.backupAccount(_uiKeyring.default.getPair(address), password);
+    const decoded = (0, _decode.decodePair)(password, (0, _utilCrypto.base64Decode)(exportedJson.encoded), exportedJson.encoding.type);
+    return {
+      privateKey: (0, _util.u8aToHex)(decoded.secretKey),
+      publicKey: (0, _util.u8aToHex)(decoded.publicKey)
+    };
+  }
+}
+exports.AccountSecretHandler = AccountSecretHandler;

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

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Derive = require("./Derive");
+Object.keys(_Derive).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Derive[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Derive[key];
+    }
+  });
+});
+var _Inject = require("./Inject");
+Object.keys(_Inject).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Inject[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Inject[key];
+    }
+  });
+});
+var _Json = require("./Json");
+Object.keys(_Json).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Json[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Json[key];
+    }
+  });
+});
+var _Ledger = require("./Ledger");
+Object.keys(_Ledger).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Ledger[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Ledger[key];
+    }
+  });
+});
+var _Mnemonic = require("./Mnemonic");
+Object.keys(_Mnemonic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Mnemonic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Mnemonic[key];
+    }
+  });
+});
+var _Modify = require("./Modify");
+Object.keys(_Modify).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Modify[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Modify[key];
+    }
+  });
+});
+var _Secret = require("./Secret");
+Object.keys(_Secret).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Secret[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Secret[key];
+    }
+  });
+});