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

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

@@ -0,0 +1,206 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
+import { createAccountProxyId, getSuri } from '@subwallet/extension-base/utils';
+import { tonMnemonicGenerate } from '@subwallet/keyring';
+import { tonMnemonicValidate } from '@subwallet/keyring/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert, isHex } from '@polkadot/util';
+import { keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
+import { AccountBaseHandler } from "./Base.js";
+export const SEED_DEFAULT_LENGTH = 12;
+export const SEED_LENGTHS = [12, 15, 18, 21, 24];
+
+/**
+ * @class AccountMnemonicHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+export class AccountMnemonicHandler extends AccountBaseHandler {
+  /* Create with mnemonic */
+
+  /* Create seed */
+  async mnemonicCreateV2({
+    length = SEED_DEFAULT_LENGTH,
+    mnemonic: _seed,
+    type = 'general'
+  }) {
+    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton'] : ['ton-native'];
+    const seed = _seed || type === 'general' ? mnemonicGenerate(length) : await tonMnemonicGenerate(length);
+    const rs = {
+      mnemonic: seed,
+      addressMap: {}
+    };
+    types === null || types === void 0 ? void 0 : types.forEach(type => {
+      rs.addressMap[type] = keyring.createFromUri(getSuri(seed, type), {}, type).address;
+    });
+    return rs;
+  }
+
+  /* Validate seed */
+  mnemonicValidateV2({
+    mnemonic
+  }) {
+    const {
+      phrase
+    } = keyExtractSuri(mnemonic);
+    let mnemonicTypes = 'general';
+    let pairTypes = [];
+    if (isHex(phrase)) {
+      assert(isHex(phrase, 256), t('Invalid seed phrase. Please try again.'));
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      assert(SEED_LENGTHS.includes(phrase.split(' ').length), t('Seed phrase needs to contain {{x}} words', {
+        replace: {
+          x: SEED_LENGTHS.join(', ')
+        }
+      }));
+      try {
+        assert(mnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
+        mnemonicTypes = 'general';
+        pairTypes = ['sr25519', 'ethereum', 'ton'];
+      } catch (e) {
+        assert(tonMnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
+        mnemonicTypes = 'ton';
+        pairTypes = ['ton-native'];
+      }
+    }
+    const rs = {
+      mnemonic,
+      addressMap: {},
+      mnemonicTypes,
+      pairTypes
+    };
+    pairTypes.forEach(type => {
+      rs.addressMap[type] = keyring.createFromUri(getSuri(mnemonic, type), {}, type).address;
+    });
+    const exists = this.state.checkAddressExists(Object.values(rs.addressMap));
+    assert(!exists, 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 = keyring.keyring.hasMasterPassword;
+    const types = type ? [type] : ['sr25519', 'ethereum', 'ton'];
+    if (!hasMasterPassword) {
+      if (!password) {
+        throw Error(t('The password of each account is needed to set up master password'));
+      } else {
+        keyring.changeMasterPassword(password);
+        this.parentService.updateKeyringState();
+      }
+    }
+    if (!types || !types.length) {
+      throw Error(t('Please choose at least one account type'));
+    }
+    const nameExists = this.state.checkNameExists(name);
+    if (nameExists) {
+      throw new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
+    }
+    const multiChain = types.length > 1;
+    const proxyId = multiChain ? createAccountProxyId(_suri) : '';
+    const modifiedPairs = this.state.modifyPairs;
+    types.forEach(type => {
+      const suri = getSuri(_suri, type);
+      const pair = 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));
+    assert(!exists, 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 = getSuri(_suri, type);
+      const {
+        derivePath
+      } = keyExtractSuri(suri);
+      const metadata = {
+        name,
+        derivationPath: derivePath ? derivePath.substring(1) : undefined
+      };
+      const rs = 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({
+    password,
+    proxyId
+  }) {
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    if (!isUnified) {
+      const pair = keyring.getPair(proxyId);
+      assert(pair, 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 = keyring.getPair(address);
+        if (pair && pair.haveEntropy) {
+          break;
+        }
+      }
+      assert(pair, t('Unable to find account'));
+      const result = pair.exportMnemonic(password) || '';
+      return {
+        result
+      };
+    }
+  }
+
+  /* Export mnemonic */
+}

package/services/keyring-service/context/handlers/Modify.d.ts

@@ -0,0 +1,16 @@
+import { RequestChangeMasterPassword, RequestMigratePassword, ResponseChangeMasterPassword, ResponseMigratePassword } from '@subwallet/extension-base/background/KoniTypes';
+import { RequestAccountProxyEdit, RequestAccountProxyForget, RequestChangeTonWalletContractVersion, RequestGetAllTonWalletContractVersion, ResponseGetAllTonWalletContractVersion } from '@subwallet/extension-base/types';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountModifyHandler
+ * @extends AccountBaseHandler
+ * @description Handler for modify account actions (change master password, migrate master password, edit account, forget account, ...)
+ * */
+export declare class AccountModifyHandler extends AccountBaseHandler {
+    keyringChangeMasterPassword(request: RequestChangeMasterPassword, callback: () => void): ResponseChangeMasterPassword;
+    keyringMigrateMasterPassword(request: RequestMigratePassword, callback: () => void): ResponseMigratePassword;
+    accountsEdit({ name, proxyId }: RequestAccountProxyEdit): boolean;
+    accountProxyForget({ proxyId }: RequestAccountProxyForget): Promise<string[]>;
+    tonGetAllTonWalletContractVersion(request: RequestGetAllTonWalletContractVersion): ResponseGetAllTonWalletContractVersion;
+    tonAccountChangeWalletContractVersion(request: RequestChangeTonWalletContractVersion): string;
+}

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

@@ -0,0 +1,250 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { AccountChainType, CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
+import { TonKeypairTypes } from '@subwallet/keyring/types';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert } from '@polkadot/util';
+import { AccountBaseHandler } from "./Base.js";
+
+/**
+ * @class AccountModifyHandler
+ * @extends AccountBaseHandler
+ * @description Handler for modify account actions (change master password, migrate master password, edit account, forget account, ...)
+ * */
+export class AccountModifyHandler extends AccountBaseHandler {
+  keyringChangeMasterPassword(request, callback) {
+    const {
+      createNew,
+      newPassword,
+      oldPassword
+    } = request;
+    try {
+      // Remove isMasterPassword meta if createNew
+      if (createNew && !keyring.keyring.hasMasterPassword) {
+        const pairs = 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);
+            keyring.saveAccountMeta(pair, pair.meta);
+          }
+        }
+      }
+      keyring.changeMasterPassword(newPassword, oldPassword);
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [t(e.message)],
+        status: false
+      };
+    }
+    this.parentService.updateKeyringState();
+    callback();
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringMigrateMasterPassword(request, callback) {
+    const {
+      address,
+      password
+    } = request;
+    try {
+      keyring.migrateWithMasterPassword(address, password);
+      callback();
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  accountsEdit({
+    name,
+    proxyId
+  }) {
+    const accountProxies = this.state.accountProxies;
+    const modifyPairs = this.state.modifyPairs;
+    const nameExists = this.state.checkNameExists(name, proxyId);
+    if (nameExists) {
+      throw new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NAME_EXISTED);
+    }
+    if (!accountProxies[proxyId]) {
+      const pair = keyring.getPair(proxyId);
+      assert(pair, t('Unable to find account'));
+      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 = keyring.getPair(address);
+        assert(pair, t('Unable to find account'));
+        keyring.saveAccountMeta(pair, {
+          ...pair.meta,
+          name
+        });
+      }
+    }
+    return true;
+  }
+  async accountProxyForget({
+    proxyId
+  }) {
+    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) {
+      keyring.forgetAccount(address);
+    }
+    await Promise.all(addresses.map(address => new Promise(resolve => this.state.removeAccountRef(address, resolve))));
+    this.state.saveCurrentAccountProxyId(ALL_ACCOUNT_KEY);
+    return addresses;
+  }
+  tonGetAllTonWalletContractVersion(request) {
+    const {
+      address,
+      isTestnet
+    } = request;
+    const pair = 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 === AccountChainType.TON);
+      if (tonAccount) {
+        modifyAddress = tonAccount.address;
+      }
+    };
+    if (address) {
+      try {
+        keyring.getPair(address);
+        modifyAddress = address;
+      } catch (e) {
+        findAddressByProxyId();
+      }
+    } else {
+      findAddressByProxyId();
+    }
+    if (!modifyAddress) {
+      throw new Error('Account not found');
+    }
+    const pair = keyring.getPair(modifyAddress);
+    if (!pair) {
+      throw new Error('Account not found');
+    }
+    if (!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];
+    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 = keyring.getPairs();
+    const childPairs = pairs.filter(pair => pair.meta.parentAddress === oldAddress);
+    for (const childPair of childPairs) {
+      assert(pair, t('Unable to find account'));
+      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;
+  }
+}

package/services/keyring-service/context/handlers/Secret.d.ts

@@ -0,0 +1,16 @@
+import { AccountExternalError, RequestAccountCreateExternalV2, RequestAccountCreateWithSecretKey, RequestAccountExportPrivateKey, ResponseAccountCreateWithSecretKey, ResponseAccountExportPrivateKey } from '@subwallet/extension-base/background/KoniTypes';
+import { RequestCheckPublicAndSecretKey, RequestPrivateKeyValidateV2, ResponseCheckPublicAndSecretKey, ResponsePrivateKeyValidateV2 } from '@subwallet/extension-base/types';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountSecretHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+export declare class AccountSecretHandler extends AccountBaseHandler {
+    accountsCreateExternalV2(request: RequestAccountCreateExternalV2): Promise<AccountExternalError[]>;
+    private _checkValidatePrivateKey;
+    privateKeyValidateV2({ chainType, privateKey }: RequestPrivateKeyValidateV2): ResponsePrivateKeyValidateV2;
+    accountsCreateWithSecret(request: RequestAccountCreateWithSecretKey): Promise<ResponseAccountCreateWithSecretKey>;
+    checkPublicAndSecretKey({ publicKey, secretKey }: RequestCheckPublicAndSecretKey): ResponseCheckPublicAndSecretKey;
+    accountExportPrivateKey(request: RequestAccountExportPrivateKey): ResponseAccountExportPrivateKey;
+}