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

package/services/keyring-service/context/account-context.js

@@ -0,0 +1,250 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountDeriveHandler, AccountInjectHandler, AccountJsonHandler, AccountLedgerHandler, AccountMnemonicHandler, AccountModifyHandler, AccountSecretHandler } from "./handlers/index.js";
+import { AccountState } from "./state.js";
+export class AccountContext {
+  constructor(koniState, parentService) {
+    this.koniState = koniState;
+    this.parentService = parentService;
+    this.state = new AccountState(this.koniState);
+    this.deriveHandler = new AccountDeriveHandler(this.parentService, this.state);
+    this.mnemonicHandler = new AccountMnemonicHandler(this.parentService, this.state);
+    this.jsonHandler = new AccountJsonHandler(this.parentService, this.state);
+    this.injectHandler = new AccountInjectHandler(this.parentService, this.state);
+    this.ledgerHandler = new AccountLedgerHandler(this.parentService, this.state);
+    this.modifyHandler = new AccountModifyHandler(this.parentService, this.state);
+    this.secretHandler = new AccountSecretHandler(this.parentService, this.state);
+  }
+
+  // TODO: Merge to value
+  get pairs() {
+    return this.state.pairs;
+  }
+
+  // TODO: Merge to value
+  get observable() {
+    return this.state.observable;
+  }
+  get value() {
+    return this.state.value;
+  }
+
+  // TODO: Merge to value
+  get contacts() {
+    return this.state.contacts;
+  }
+
+  // TODO: Merge to value
+  get accounts() {
+    return this.state.accounts;
+  }
+
+  /* Current account */
+
+  // TODO: Merge to value
+  get currentAccount() {
+    return this.state.currentAccount;
+  }
+  saveCurrentAccountProxyId(proxyId, callback, preventOneAccount) {
+    this.state.saveCurrentAccountProxyId(proxyId, callback, preventOneAccount);
+  }
+
+  /* Current account */
+
+  isUnifiedAccount(proxyId) {
+    return this.state.isUnifiedAccount(proxyId);
+  }
+  addressesByProxyId(proxyId) {
+    return this.state.addressesByProxyId(proxyId);
+  }
+
+  /* Modify accounts */
+
+  accountsEdit(request) {
+    return this.modifyHandler.accountsEdit(request);
+  }
+  checkNameExists({
+    name,
+    proxyId
+  }) {
+    const exists = this.state.checkNameExists(name, proxyId);
+    return {
+      isValid: !exists
+    };
+  }
+  async accountProxyForget(request) {
+    return this.modifyHandler.accountProxyForget(request);
+  }
+  keyringChangeMasterPassword(request, callback) {
+    return this.modifyHandler.keyringChangeMasterPassword(request, callback);
+  }
+  keyringMigrateMasterPassword(request, callback) {
+    return this.modifyHandler.keyringMigrateMasterPassword(request, callback);
+  }
+  tonGetAllTonWalletContractVersion(request) {
+    return this.modifyHandler.tonGetAllTonWalletContractVersion(request);
+  }
+  tonAccountChangeWalletContractVersion(request) {
+    return this.modifyHandler.tonAccountChangeWalletContractVersion(request);
+  }
+
+  /* Modify accounts */
+
+  /* Get address for another service */
+
+  getDecodedAddresses(accountProxy, allowGetAllAccount = true) {
+    return this.state.getDecodedAddresses(accountProxy, allowGetAllAccount);
+  }
+
+  /* Get address for another service */
+
+  /* Mnemonic */
+
+  /* Create seed */
+  mnemonicCreateV2(request) {
+    return this.mnemonicHandler.mnemonicCreateV2(request);
+  }
+
+  /* Validate seed */
+  mnemonicValidateV2(request) {
+    return this.mnemonicHandler.mnemonicValidateV2(request);
+  }
+
+  /* Add accounts from mnemonic */
+  accountsCreateSuriV2(request) {
+    return this.mnemonicHandler.accountsCreateSuriV2(request);
+  }
+
+  /* Export mnemonic */
+  exportAccountProxyMnemonic(request) {
+    return this.mnemonicHandler.exportAccountProxyMnemonic(request);
+  }
+
+  /* Mnemonic */
+
+  /* Add QR-signer, read-only */
+  async accountsCreateExternalV2(request) {
+    return this.secretHandler.accountsCreateExternalV2(request);
+  }
+
+  /* Import ethereum account with the private key  */
+  privateKeyValidateV2(request) {
+    return this.secretHandler.privateKeyValidateV2(request);
+  }
+
+  /* Import ethereum account with the private key  */
+
+  /* Ledger */
+
+  /* For custom derive path */
+  async accountsCreateHardwareV2(request) {
+    return this.ledgerHandler.accountsCreateHardwareV2(request);
+  }
+
+  /* For multi select */
+  async accountsCreateHardwareMultiple(request) {
+    return this.ledgerHandler.accountsCreateHardwareMultiple(request);
+  }
+
+  /* Ledger */
+
+  /* JSON */
+
+  parseInfoSingleJson(request) {
+    return this.jsonHandler.parseInfoSingleJson(request);
+  }
+  jsonRestoreV2(request, onDone) {
+    return this.jsonHandler.jsonRestoreV2(request, onDone);
+  }
+  parseInfoMultiJson(request) {
+    return this.jsonHandler.parseInfoMultiJson(request);
+  }
+  batchRestoreV2(request) {
+    return this.jsonHandler.batchRestoreV2(request);
+  }
+  batchExportV2(request) {
+    return this.jsonHandler.batchExportV2(request);
+  }
+
+  /* JSON */
+
+  /* Add with secret and public key */
+  async accountsCreateWithSecret(request) {
+    return this.secretHandler.accountsCreateWithSecret(request);
+  }
+  checkPublicAndSecretKey(request) {
+    return this.secretHandler.checkPublicAndSecretKey(request);
+  }
+  accountExportPrivateKey(request) {
+    return this.secretHandler.accountExportPrivateKey(request);
+  }
+
+  /* Derive */
+
+  /**
+   * @func derivationCreateMultiple
+   * @desc Derive multi account
+   * Note: Must update before re-use
+   * @deprecated
+   */
+  derivationCreateMultiple(request) {
+    return this.deriveHandler.derivationCreateMultiple(request);
+  }
+
+  /**
+   * @func getListDeriveAccounts
+   * @desc Get a derivation account list.
+   * Note: Must update before re-use
+   * @deprecated
+   */
+  getListDeriveAccounts(request) {
+    return this.deriveHandler.getListDeriveAccounts(request);
+  }
+
+  /* Validate derivation path */
+  validateDerivePath(request) {
+    return this.deriveHandler.validateDerivePath(request);
+  }
+
+  /* Validate derivation path */
+  getDeriveSuggestion(request) {
+    return this.deriveHandler.getDeriveSuggestion(request);
+  }
+
+  /* Derive account proxy  */
+  derivationAccountProxyCreate(request) {
+    return this.deriveHandler.derivationAccountProxyCreate(request);
+  }
+
+  /* Derive */
+
+  /* Inject */
+
+  addInjectAccounts(accounts) {
+    this.injectHandler.addInjectAccounts(accounts);
+  }
+  removeInjectAccounts(_addresses) {
+    this.injectHandler.removeInjectAccounts(_addresses);
+  }
+
+  /* Inject */
+
+  /* Others */
+
+  removeNoneHardwareGenesisHash() {
+    this.state.removeNoneHardwareGenesisHash();
+  }
+  updateMetadataForPair() {
+    this.state.updateMetadataForPair();
+  }
+
+  /* Others */
+
+  /* Reset wallet */
+  resetWallet() {
+    this.state.resetWallet();
+  }
+
+  /* Reset wallet */
+}

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

@@ -0,0 +1,11 @@
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
+import { AccountState } from '../state';
+/**
+ * @class AccountBaseHandler
+ * @description Base class for account actions
+ * */
+export declare class AccountBaseHandler {
+    protected readonly state: AccountState;
+    protected readonly parentService: KeyringService;
+    constructor(parentService: KeyringService, state: AccountState);
+}

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

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class AccountBaseHandler
+ * @description Base class for account actions
+ * */
+export class AccountBaseHandler {
+  constructor(parentService, state) {
+    this.state = state;
+    this.parentService = parentService;
+  }
+}

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

@@ -0,0 +1,29 @@
+import { RequestDeriveCreateMultiple, RequestDeriveCreateV3, RequestDeriveValidateV2, RequestGetDeriveAccounts, RequestGetDeriveSuggestion, ResponseDeriveValidateV2, ResponseGetDeriveAccounts, ResponseGetDeriveSuggestion } from '@subwallet/extension-base/types';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountDeriveHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account derivation
+ * */
+export declare class AccountDeriveHandler extends AccountBaseHandler {
+    /**
+     * @func derivationCreateMultiple
+     * @desc Derive multi account
+     * @todo Must update before re-use
+     * @deprecated
+     */
+    derivationCreateMultiple({ isAllowed, items, parentAddress }: RequestDeriveCreateMultiple): boolean;
+    /**
+     * @func getListDeriveAccounts
+     * @desc Get a derivation account list.
+     * @todo Must update before re-use
+     * @deprecated
+     */
+    getListDeriveAccounts({ limit, page, parentAddress }: RequestGetDeriveAccounts): ResponseGetDeriveAccounts;
+    validateDerivePath({ proxyId, suri }: RequestDeriveValidateV2): ResponseDeriveValidateV2;
+    getDeriveSuggestion({ proxyId }: RequestGetDeriveSuggestion): ResponseGetDeriveSuggestion;
+    /**
+     * Derive account proxy
+     *  */
+    derivationAccountProxyCreate(request: RequestDeriveCreateV3): boolean;
+}

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

@@ -0,0 +1,365 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { CommonAccountErrorType, DeriveErrorType, SWCommonAccountError, SWDeriveError } from '@subwallet/extension-base/types';
+import { createAccountProxyId, derivePair, findSoloNextDerive, findUnifiedNextDerive, getSoloDerivationInfo, parseUnifiedSuriToDerivationPath, validateDerivationPath } from '@subwallet/extension-base/utils';
+import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert } from '@polkadot/util';
+import { AccountBaseHandler } from "./Base.js";
+const validDeriveKeypairTypes = [...SubstrateKeypairTypes, ...EthereumKeypairTypes, 'ton'];
+
+/**
+ * @class AccountDeriveHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account derivation
+ * */
+export class AccountDeriveHandler extends AccountBaseHandler {
+  /* Derive */
+
+  /**
+   * @func derivationCreateMultiple
+   * @desc Derive multi account
+   * @todo Must update before re-use
+   * @deprecated
+   */
+  derivationCreateMultiple({
+    isAllowed,
+    items,
+    parentAddress
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    const createChild = ({
+      name,
+      suri
+    }) => {
+      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 SWDeriveError(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;
+        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(ALL_ACCOUNT_KEY);
+    }
+    return true;
+  }
+
+  /**
+   * @func getListDeriveAccounts
+   * @desc Get a derivation account list.
+   * @todo Must update before re-use
+   * @deprecated
+   */
+  getListDeriveAccounts({
+    limit,
+    page,
+    parentAddress
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      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({
+    proxyId,
+    suri
+  }) {
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    let type;
+    if (!isUnified) {
+      try {
+        const pair = keyring.getPair(proxyId);
+        type = pair.type;
+      } catch (e) {
+        throw new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+      }
+    }
+    const derivationInfo = 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 SWDeriveError(DeriveErrorType.MIN_DERIVATION_DEPTH).toJSON()
+        };
+      }
+
+      /* Maximum depth is 2 */
+      if (derivationInfo.depth > 2) {
+        return {
+          info: undefined,
+          error: new SWDeriveError(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 SWDeriveError(DeriveErrorType.INVALID_DERIVATION_TYPE).toJSON()
+        };
+      }
+    } else {
+      return {
+        info: undefined,
+        error: new SWDeriveError(DeriveErrorType.INVALID_DERIVATION_PATH).toJSON()
+      };
+    }
+  }
+  getDeriveSuggestion({
+    proxyId
+  }) {
+    const isUnified = this.state.isUnifiedAccount(proxyId);
+    let rs;
+    if (isUnified) {
+      rs = findUnifiedNextDerive(proxyId, this.state.accounts);
+    } else {
+      let pair;
+      try {
+        pair = keyring.getPair(proxyId);
+      } catch (e) {}
+      if (!pair) {
+        return {
+          proxyId,
+          error: new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NOT_FOUND).toJSON()
+        };
+      }
+      if (!validDeriveKeypairTypes.includes(pair.type)) {
+        return {
+          proxyId,
+          error: new SWDeriveError(DeriveErrorType.INVALID_ACCOUNT_TYPE).toJSON()
+        };
+      }
+      rs = 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 SWCommonAccountError(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 SWDeriveError(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 = getSoloDerivationInfo(account.type, account);
+      const needChangeRoot = deriveInfo.depth > 0;
+      let rootPair;
+      if (needChangeRoot) {
+        try {
+          rootPair = keyring.getPair(account.parentAddress || '');
+        } catch (e) {}
+      } else {
+        try {
+          rootPair = keyring.getPair(account.address);
+        } catch (e) {}
+      }
+      return rootPair;
+    };
+    if (derivationInfo.type === 'unified') {
+      const accountProxy = this.state.value.accounts[deriveId];
+      if (!accountProxy) {
+        throw new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+      }
+      const accounts = accountProxy.accounts;
+      proxyId = createAccountProxyId(rootProxyId, suri);
+      for (const account of accounts) {
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new SWDeriveError(DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const derivationPath = parseUnifiedSuriToDerivationPath(derivationInfo.suri, account.type);
+        const childPair = 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 SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+        }
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new SWDeriveError(DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const childPair = 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 SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NOT_FOUND);
+        }
+        const rootPair = findRootPair(account);
+        if (!rootPair) {
+          throw new SWDeriveError(DeriveErrorType.ROOT_ACCOUNT_NOT_FOUND);
+        }
+        const childPair = 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);
+    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) || ''
+      }
+    }));
+    childAccountProxy && this.state.upsertAccountProxyByKey(childAccountProxy);
+    this.state.upsertModifyPairs(modifyPairs);
+    for (const childPair of pairs) {
+      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 */
+}

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

@@ -0,0 +1,11 @@
+import { InjectedAccountWithMeta } from '@subwallet/extension-inject/types';
+import { AccountBaseHandler } from './Base';
+/**
+ * @class AccountInjectHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account inject actions
+ * */
+export declare class AccountInjectHandler extends AccountBaseHandler {
+    addInjectAccounts(accounts: InjectedAccountWithMeta[]): void;
+    removeInjectAccounts(_addresses: string[]): void;
+}