@subwallet/extension-base 1.2.32-0 → 1.3.1

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

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SEED_LENGTHS = exports.SEED_DEFAULT_LENGTH = exports.AccountMnemonicHandler = void 0;
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _utils2 = require("@subwallet/keyring/utils");
+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
+
+const SEED_DEFAULT_LENGTH = 12;
+exports.SEED_DEFAULT_LENGTH = SEED_DEFAULT_LENGTH;
+const SEED_LENGTHS = [12, 15, 18, 21, 24];
+
+/**
+ * @class AccountMnemonicHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+exports.SEED_LENGTHS = SEED_LENGTHS;
+class AccountMnemonicHandler extends _Base.AccountBaseHandler {
+  /* Create with mnemonic */
+
+  /* Create seed */
+  async mnemonicCreateV2(_ref) {
+    let {
+      length = SEED_DEFAULT_LENGTH,
+      mnemonic: _seed,
+      type = 'general'
+    } = _ref;
+    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton'] : ['ton-native'];
+    const seed = _seed || type === 'general' ? (0, _utilCrypto.mnemonicGenerate)(length) : await (0, _keyring.tonMnemonicGenerate)(length);
+    const rs = {
+      mnemonic: seed,
+      addressMap: {}
+    };
+    types === null || types === void 0 ? void 0 : types.forEach(type => {
+      rs.addressMap[type] = _uiKeyring.keyring.createFromUri((0, _utils.getSuri)(seed, type), {}, type).address;
+    });
+    return rs;
+  }
+
+  /* Validate seed */
+  mnemonicValidateV2(_ref2) {
+    let {
+      mnemonic
+    } = _ref2;
+    const {
+      phrase
+    } = (0, _utilCrypto.keyExtractSuri)(mnemonic);
+    let mnemonicTypes = 'general';
+    let pairTypes = [];
+    if ((0, _util.isHex)(phrase)) {
+      (0, _util.assert)((0, _util.isHex)(phrase, 256), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      (0, _util.assert)(SEED_LENGTHS.includes(phrase.split(' ').length), (0, _i18next.t)('Seed phrase needs to contain {{x}} words', {
+        replace: {
+          x: SEED_LENGTHS.join(', ')
+        }
+      }));
+      try {
+        (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
+        mnemonicTypes = 'general';
+        pairTypes = ['sr25519', 'ethereum', 'ton'];
+      } catch (e) {
+        (0, _util.assert)((0, _utils2.tonMnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
+        mnemonicTypes = 'ton';
+        pairTypes = ['ton-native'];
+      }
+    }
+    const rs = {
+      mnemonic,
+      addressMap: {},
+      mnemonicTypes,
+      pairTypes
+    };
+    pairTypes.forEach(type => {
+      rs.addressMap[type] = _uiKeyring.keyring.createFromUri((0, _utils.getSuri)(mnemonic, type), {}, type).address;
+    });
+    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;
+  }
+
+  /* Add accounts from mnemonic */
+  accountsCreateSuriV2(request) {
+    const {
+      isAllowed,
+      name,
+      password,
+      suri: _suri,
+      type
+    } = request;
+    const addressDict = {};
+    let changedAccount = false;
+    const hasMasterPassword = _uiKeyring.keyring.keyring.hasMasterPassword;
+    const types = type ? [type] : ['sr25519', 'ethereum', 'ton'];
+    if (!hasMasterPassword) {
+      if (!password) {
+        throw Error((0, _i18next.t)('The password of each account is needed to set up master password'));
+      } else {
+        _uiKeyring.keyring.changeMasterPassword(password);
+        this.parentService.updateKeyringState();
+      }
+    }
+    if (!types || !types.length) {
+      throw Error((0, _i18next.t)('Please choose at least one account type'));
+    }
+    const nameExists = this.state.checkNameExists(name);
+    if (nameExists) {
+      throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
+    }
+    const multiChain = types.length > 1;
+    const proxyId = multiChain ? (0, _utils.createAccountProxyId)(_suri) : '';
+    const modifiedPairs = this.state.modifyPairs;
+    types.forEach(type => {
+      const suri = (0, _utils.getSuri)(_suri, type);
+      const pair = _uiKeyring.keyring.createFromUri(suri, {}, type);
+      const address = pair.address;
+      modifiedPairs[address] = {
+        accountProxyId: proxyId,
+        migrated: true,
+        key: address
+      };
+      addressDict[type] = address;
+    });
+    const exists = this.state.checkAddressExists(Object.values(addressDict));
+    (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) || ''
+      }
+    }));
+
+    // Upsert account group first, to avoid combine latest have no account group data.
+    if (proxyId) {
+      this.state.upsertAccountProxyByKey({
+        id: proxyId,
+        name
+      });
+    }
+
+    // Upsert modify pair before add account to keyring
+    this.state.upsertModifyPairs(modifiedPairs);
+    types.forEach(type => {
+      const suri = (0, _utils.getSuri)(_suri, type);
+      const {
+        derivePath
+      } = (0, _utilCrypto.keyExtractSuri)(suri);
+      const metadata = {
+        name,
+        derivationPath: derivePath ? derivePath.substring(1) : undefined
+      };
+      const rs = _uiKeyring.keyring.addUri(suri, metadata, type);
+      const address = rs.pair.address;
+      this.state._addAddressToAuthList(address, isAllowed);
+      if (!changedAccount) {
+        if (!proxyId) {
+          this.state.saveCurrentAccountProxyId(address);
+        } else {
+          this.state.saveCurrentAccountProxyId(proxyId);
+        }
+        changedAccount = true;
+      }
+    });
+    return addressDict;
+  }
+
+  /* Create with mnemonic */
+
+  /* Export mnemonic */
+
+  exportAccountProxyMnemonic(_ref3) {
+    let {
+      password,
+      proxyId
+    } = _ref3;
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    if (!isUnified) {
+      const pair = _uiKeyring.keyring.getPair(proxyId);
+      (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
+      const result = pair.exportMnemonic(password);
+      return {
+        result
+      };
+    } else {
+      const modifyPairs = this.state.modifyPairs;
+      const addresses = Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
+      let pair;
+      for (const address of addresses) {
+        pair = _uiKeyring.keyring.getPair(address);
+        if (pair && pair.haveEntropy) {
+          break;
+        }
+      }
+      (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
+      const result = pair.exportMnemonic(password) || '';
+      return {
+        result
+      };
+    }
+  }
+
+  /* Export mnemonic */
+}
+exports.AccountMnemonicHandler = AccountMnemonicHandler;

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

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountModifyHandler = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/types");
+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
+
+/**
+ * @class AccountModifyHandler
+ * @extends AccountBaseHandler
+ * @description Handler for modify account actions (change master password, migrate master password, edit account, forget account, ...)
+ * */
+class AccountModifyHandler extends _Base.AccountBaseHandler {
+  keyringChangeMasterPassword(request, callback) {
+    const {
+      createNew,
+      newPassword,
+      oldPassword
+    } = request;
+    try {
+      // Remove isMasterPassword meta if createNew
+      if (createNew && !_uiKeyring.keyring.keyring.hasMasterPassword) {
+        const pairs = _uiKeyring.keyring.getPairs();
+        for (const pair of pairs) {
+          if (pair.meta.isInjected) {
+            // Empty
+          } else {
+            const meta = {
+              ...pair.meta,
+              isMasterPassword: false
+            };
+            if (!meta.originGenesisHash) {
+              meta.genesisHash = '';
+            }
+            pair.setMeta(meta);
+            _uiKeyring.keyring.saveAccountMeta(pair, pair.meta);
+          }
+        }
+      }
+      _uiKeyring.keyring.changeMasterPassword(newPassword, oldPassword);
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [(0, _i18next.t)(e.message)],
+        status: false
+      };
+    }
+    this.parentService.updateKeyringState();
+    callback();
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringMigrateMasterPassword(request, callback) {
+    const {
+      address,
+      password
+    } = request;
+    try {
+      _uiKeyring.keyring.migrateWithMasterPassword(address, password);
+      callback();
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  accountsEdit(_ref) {
+    let {
+      name,
+      proxyId
+    } = _ref;
+    const accountProxies = this.state.accountProxies;
+    const modifyPairs = this.state.modifyPairs;
+    const nameExists = this.state.checkNameExists(name, proxyId);
+    if (nameExists) {
+      throw new _types.SWCommonAccountError(_types.CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
+    }
+    if (!accountProxies[proxyId]) {
+      const pair = _uiKeyring.keyring.getPair(proxyId);
+      (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
+      _uiKeyring.keyring.saveAccountMeta(pair, {
+        ...pair.meta,
+        name
+      });
+    } else {
+      const accountProxy = accountProxies[proxyId];
+      const addresses = Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
+      accountProxy.name = name;
+      this.state.upsertAccountProxyByKey(accountProxy);
+      for (const address of addresses) {
+        const pair = _uiKeyring.keyring.getPair(address);
+        (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
+        _uiKeyring.keyring.saveAccountMeta(pair, {
+          ...pair.meta,
+          name
+        });
+      }
+    }
+    return true;
+  }
+  async accountProxyForget(_ref2) {
+    let {
+      proxyId
+    } = _ref2;
+    const modifyPairs = this.state.modifyPairs;
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    let addresses;
+    if (!isUnified) {
+      addresses = [proxyId];
+    } else {
+      addresses = Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
+      this.state.deleteAccountProxy(proxyId);
+      this.parentService.eventRemoveAccount(proxyId);
+    }
+    for (const address of addresses) {
+      delete modifyPairs[address];
+    }
+    this.state.upsertModifyPairs(modifyPairs);
+    for (const address of addresses) {
+      _uiKeyring.keyring.forgetAccount(address);
+    }
+    await Promise.all(addresses.map(address => new Promise(resolve => this.state.removeAccountRef(address, resolve))));
+    this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    return addresses;
+  }
+  tonGetAllTonWalletContractVersion(request) {
+    const {
+      address,
+      isTestnet
+    } = request;
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (!pair) {
+      throw new Error('Account not found');
+    }
+    const contractVersion = pair.meta.tonContractVersion;
+    const getContractAddress = version => {
+      return pair.ton.contractWithVersion(version).address.toString({
+        bounceable: false,
+        testOnly: isTestnet
+      });
+    };
+    const addressMap = {
+      v3r1: getContractAddress('v3r1'),
+      v3r2: getContractAddress('v3r2'),
+      v4: getContractAddress('v4'),
+      v5r1: getContractAddress('v5r1')
+    };
+    return {
+      address: pair.address,
+      currentVersion: contractVersion,
+      addressMap: addressMap
+    };
+  }
+  tonAccountChangeWalletContractVersion(request) {
+    const {
+      address,
+      proxyId,
+      version
+    } = request;
+    const accounts = this.state.accounts;
+    let modifyAddress = '';
+    const findAddressByProxyId = () => {
+      const accountProxy = accounts[proxyId];
+      if (!accountProxy) {
+        return;
+      }
+      const tonAccount = accountProxy.accounts.find(account => account.chainType === _types.AccountChainType.TON);
+      if (tonAccount) {
+        modifyAddress = tonAccount.address;
+      }
+    };
+    if (address) {
+      try {
+        _uiKeyring.keyring.getPair(address);
+        modifyAddress = address;
+      } catch (e) {
+        findAddressByProxyId();
+      }
+    } else {
+      findAddressByProxyId();
+    }
+    if (!modifyAddress) {
+      throw new Error('Account not found');
+    }
+    const pair = _uiKeyring.keyring.getPair(modifyAddress);
+    if (!pair) {
+      throw new Error('Account not found');
+    }
+    if (!_types2.TonKeypairTypes.includes(pair.type)) {
+      throw new Error('Invalid account type');
+    }
+    const oldVerion = pair.ton.contractVersion;
+    const oldAddress = pair.address;
+    if (oldVerion === version) {
+      return oldAddress;
+    }
+    const modifiedPairs = this.state.modifyPairs;
+    const modifiedPair = modifiedPairs[oldAddress];
+    const accountProxies = this.state.accountProxies;
+    const accountProxy = accountProxies[oldAddress];
+    _uiKeyring.keyring.changeTonWalletContractVersion(modifyAddress, version);
+    const newAddress = pair.address;
+
+    // Migrate modified pair
+    if (modifiedPair) {
+      delete modifiedPairs[oldAddress];
+      if (modifiedPair.accountProxyId === oldAddress) {
+        modifiedPair.accountProxyId = newAddress;
+      }
+      modifiedPair.key = newAddress;
+      modifiedPairs[newAddress] = modifiedPair;
+    }
+
+    // Migrate account proxy
+    if (accountProxy) {
+      delete accountProxies[oldAddress];
+      accountProxy.id = newAddress;
+      accountProxies[newAddress] = accountProxy;
+    }
+    const pairs = _uiKeyring.keyring.getPairs();
+    const childPairs = pairs.filter(pair => pair.meta.parentAddress === oldAddress);
+    for (const childPair of childPairs) {
+      (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
+      _uiKeyring.keyring.saveAccountMeta(childPair, {
+        ...childPair.meta,
+        parentAddress: newAddress
+      });
+    }
+
+    // In case the current account is a single account, and is the account being modified, update the current proxy id
+    const currentProxy = this.state.currentAccount.proxyId;
+    if (currentProxy === oldAddress) {
+      this.state.saveCurrentAccountProxyId(newAddress);
+    }
+    this.state.upsertModifyPairs(modifiedPairs);
+    this.state.upsertAccountProxy(accountProxies);
+    this.state.changeAddressAllowedAuthList(oldAddress, newAddress);
+    return newAddress;
+  }
+}
+exports.AccountModifyHandler = AccountModifyHandler;