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

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

@@ -0,0 +1,69 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { keyring } from '@subwallet/ui-keyring';
+import { stringShorten } from '@polkadot/util';
+import { AccountBaseHandler } from "./Base.js";
+
+/**
+ * @class AccountInjectHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account inject actions
+ * */
+export class AccountInjectHandler extends AccountBaseHandler {
+  /* Inject */
+
+  addInjectAccounts(accounts) {
+    keyring.addInjects(accounts.map(account => {
+      const name = account.meta.name || 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(ALL_ACCOUNT_KEY);
+    }
+    if (!this.state.injected) {
+      this.parentService.eventInjectReady();
+      this.state.setInjected(true);
+    }
+  }
+  removeInjectAccounts(_addresses) {
+    const addresses = _addresses.map(address => {
+      try {
+        return 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(ALL_ACCOUNT_KEY);
+    }
+    keyring.removeInjects(addresses);
+  }
+
+  /* Inject */
+}

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

@@ -0,0 +1,18 @@
+import { RequestAccountBatchExportV2, RequestBatchJsonGetAccountInfo, RequestBatchRestoreV2, RequestJsonGetAccountInfo, RequestJsonRestoreV2, ResponseAccountBatchExportV2, ResponseBatchJsonGetAccountInfo, ResponseJsonGetAccountInfo } from '@subwallet/extension-base/types';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountJsonHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's JSON
+ * */
+export declare class AccountJsonHandler extends AccountBaseHandler {
+    private decodeAddress;
+    private encodeAddress;
+    private validatePassword;
+    parseInfoSingleJson({ json, password }: RequestJsonGetAccountInfo): ResponseJsonGetAccountInfo;
+    jsonRestoreV2({ address, file, isAllowed, password, withMasterPassword }: RequestJsonRestoreV2, onDone: VoidFunction): Promise<string[]>;
+    private validatedAccountsPassword;
+    parseInfoMultiJson({ json, password }: RequestBatchJsonGetAccountInfo): ResponseBatchJsonGetAccountInfo;
+    batchRestoreV2({ file, isAllowed, password, proxyIds: _proxyIds }: RequestBatchRestoreV2): Promise<string[]>;
+    batchExportV2(request: RequestAccountBatchExportV2): Promise<ResponseAccountBatchExportV2>;
+}

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

@@ -0,0 +1,328 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { combineAccountsWithKeyPair, convertAccountProxyType, createPromiseHandler, transformAccount } from '@subwallet/extension-base/utils';
+import { generateRandomString } from '@subwallet/extension-base/utils/getId';
+import { createPair } from '@subwallet/keyring';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert, hexToU8a, isHex, u8aToString } from '@polkadot/util';
+import { base64Decode, jsonDecrypt } from '@polkadot/util-crypto';
+import { AccountBaseHandler } from "./Base.js";
+
+/**
+ * @class AccountJsonHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's JSON
+ * */
+export class AccountJsonHandler extends AccountBaseHandler {
+  decodeAddress = (key, ignoreChecksum, ss58Format) => {
+    return keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+  };
+  encodeAddress = (key, ss58Format) => {
+    return 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 = createPair({
+      toSS58: this.encodeAddress,
+      type: cryptoType
+    }, {
+      publicKey: this.decodeAddress(json.address, true)
+    }, json.meta, isHex(json.encoded) ? hexToU8a(json.encoded) : 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({
+    json,
+    password
+  }) {
+    const isPasswordValidated = this.validatePassword(json, password);
+    if (isPasswordValidated) {
+      try {
+        const {
+          address,
+          meta,
+          type
+        } = keyring.createFromJson(json);
+        const {
+          name
+        } = meta;
+        const account = 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: 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(t('Incorrect password'));
+    }
+  }
+  jsonRestoreV2({
+    address,
+    file,
+    isAllowed,
+    password,
+    withMasterPassword
+  }, onDone) {
+    const isPasswordValidated = this.validatePassword(file, password);
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
+    if (isPasswordValidated) {
+      try {
+        const _pair = keyring.createFromJson(file);
+        const exists = this.state.checkAddressExists([_pair.address]);
+        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) || _pair.address
+          }
+        }));
+        keyring.restoreAccount(file, password, withMasterPassword);
+        const pair = keyring.getPair(_pair.address);
+        const _name = pair.meta.name || '';
+        const nameExists = this.state.checkNameExists(_name);
+        if (nameExists) {
+          const newName = _name.concat(' - ').concat(generateRandomString());
+          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(t('Incorrect password')));
+    }
+    return promise;
+  }
+  validatedAccountsPassword(json, password) {
+    try {
+      const decoded = u8aToString(jsonDecrypt(json, password));
+      return JSON.parse(decoded);
+    } catch (e) {
+      return null;
+    }
+  }
+  parseInfoMultiJson({
+    json,
+    password
+  }) {
+    const jsons = this.validatedAccountsPassword(json, password);
+    if (jsons) {
+      try {
+        const {
+          accountProxies,
+          modifyPairs
+        } = json;
+        const pairs = jsons.map(pair => keyring.createFromJson(pair));
+        const accountProxyMap = 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(t('Incorrect password'));
+    }
+  }
+  batchRestoreV2({
+    file,
+    isAllowed,
+    password,
+    proxyIds: _proxyIds
+  }) {
+    const jsons = this.validatedAccountsPassword(file, password);
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
+    if (jsons) {
+      try {
+        const {
+          accountProxies,
+          modifyPairs
+        } = file;
+        const pairs = jsons.map(pair => keyring.createFromJson(pair));
+        const accountProxyMap = 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(({
+          id
+        }) => rawProxyIds.includes(id)));
+        const filteredAccountProxies = Object.fromEntries(Object.entries(accountProxyMap).filter(([proxyId, accountProxy]) => {
+          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(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(t('Account already exists under the name {{name}}', {
+              replace: {
+                name: _exists.name || _exists.address || ''
+              }
+            }));
+          } else {
+            throw new Error(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] : 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);
+        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 = keyring.getPair(account.address);
+              keyring.saveAccountMeta(pair, {
+                ...pair.meta,
+                name
+              });
+            }
+          }
+        }
+        const successAddressList = addresses.reduce((rs, address) => {
+          try {
+            const account = 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(t('Incorrect password')));
+    }
+    return promise;
+  }
+  async batchExportV2(request) {
+    const {
+      password,
+      proxyIds
+    } = request;
+    try {
+      if (proxyIds && !proxyIds.length) {
+        throw new Error(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(([, modifyPair]) => _proxyIds.includes(modifyPair.accountProxyId || '')));
+      const accountProxies = Object.fromEntries(Object.entries(_accountProxy).filter(([, proxy]) => _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 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(t('Incorrect password'));
+      } else {
+        throw error;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+import { RequestAccountCreateHardwareMultiple, RequestAccountCreateHardwareV2 } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountLedgerHandler
+ * @extends AccountBaseHandler
+ * @description Handler for Ledger account actions
+ * */
+export declare class AccountLedgerHandler extends AccountBaseHandler {
+    accountsCreateHardwareV2(request: RequestAccountCreateHardwareV2): Promise<boolean>;
+    accountsCreateHardwareMultiple({ accounts }: RequestAccountCreateHardwareMultiple): Promise<boolean>;
+}

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

@@ -0,0 +1,158 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert } from '@polkadot/util';
+import { AccountBaseHandler } from "./Base.js";
+
+/**
+ * @class AccountLedgerHandler
+ * @extends AccountBaseHandler
+ * @description Handler for Ledger account actions
+ * */
+export class AccountLedgerHandler extends 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]);
+    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) || address
+      }
+    }));
+    const baseMeta = {
+      name,
+      hardwareType,
+      accountIndex,
+      addressOffset,
+      genesisHash,
+      originGenesisHash,
+      isGeneric
+    };
+    const type = isEthereum ? 'ethereum' : 'sr25519';
+    const pair = 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);
+    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({
+    accounts
+  }) {
+    const addresses = [];
+    if (!accounts.length) {
+      throw new Error(t('Can\'t find an account. Please try again'));
+    }
+    const exists = this.state.checkAddressExists(accounts.map(account => account.address));
+    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) || ''
+      }
+    }));
+    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 = 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) {
+      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(ALL_ACCOUNT_KEY);
+    }
+    if (Object.keys(slugMap).length) {
+      for (const chainSlug of Object.keys(slugMap)) {
+        this.state.enableChain(chainSlug);
+      }
+    }
+    return true;
+  }
+
+  /* Ledger */
+}

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

@@ -0,0 +1,15 @@
+import { RequestAccountCreateSuriV2, RequestExportAccountProxyMnemonic, RequestMnemonicCreateV2, RequestMnemonicValidateV2, ResponseAccountCreateSuriV2, ResponseExportAccountProxyMnemonic, ResponseMnemonicCreateV2, ResponseMnemonicValidateV2 } from '@subwallet/extension-base/types';
+import { AccountBaseHandler } from './Base';
+export declare const SEED_DEFAULT_LENGTH = 12;
+export declare const SEED_LENGTHS: number[];
+/**
+ * @class AccountMnemonicHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+export declare class AccountMnemonicHandler extends AccountBaseHandler {
+    mnemonicCreateV2({ length, mnemonic: _seed, type }: RequestMnemonicCreateV2): Promise<ResponseMnemonicCreateV2>;
+    mnemonicValidateV2({ mnemonic }: RequestMnemonicValidateV2): ResponseMnemonicValidateV2;
+    accountsCreateSuriV2(request: RequestAccountCreateSuriV2): ResponseAccountCreateSuriV2;
+    exportAccountProxyMnemonic({ password, proxyId }: RequestExportAccountProxyMnemonic): ResponseExportAccountProxyMnemonic;
+}