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

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

@@ -0,0 +1,299 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountExternalErrorCode } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountChainType, CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
+import { decodePair } from '@subwallet/keyring/pair/decode';
+import { BitcoinKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import keyring from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { assert, hexStripPrefix, hexToU8a, isHex, u8aToHex } from '@polkadot/util';
+import { base64Decode, keyExtractSuri } from '@polkadot/util-crypto';
+import { AccountBaseHandler } from "./Base.js";
+
+/**
+ * @class AccountSecretHandler
+ * @extends AccountBaseHandler
+ * @description Handler for account's mnemonic
+ * */
+export class AccountSecretHandler extends AccountBaseHandler {
+  /* Add QR-signer, read-only */
+  async accountsCreateExternalV2(request) {
+    const {
+      address,
+      isAllowed,
+      isReadOnly,
+      name
+    } = request;
+    const type = getKeypairTypeByAddress(address);
+    try {
+      try {
+        const exists = keyring.getPair(address);
+        if (exists) {
+          if (exists.type === type) {
+            return [{
+              code: AccountExternalErrorCode.INVALID_ADDRESS,
+              message: t('Account exists')
+            }];
+          }
+        }
+      } catch (e) {}
+      const nameExists = this.state.checkNameExists(name);
+      if (nameExists) {
+        throw Error(t('Account name already exists'));
+      }
+      const meta = {
+        name,
+        isExternal: true,
+        isReadOnly,
+        genesisHash: ''
+      };
+      if ([...BitcoinKeypairTypes, ...TonKeypairTypes].includes(type) && isReadOnly) {
+        meta.noPublicKey = true;
+      }
+      const result = keyring.keyring.addFromAddress(address, meta, null, type);
+      keyring.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: AccountExternalErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+
+  /* Import ethereum account with the private key  */
+  _checkValidatePrivateKey({
+    chainType,
+    privateKey
+  }, autoAddPrefix = false) {
+    const {
+      phrase
+    } = keyExtractSuri(privateKey);
+    const rs = {
+      autoAddPrefix: autoAddPrefix,
+      addressMap: {}
+    };
+    const types = [];
+    if (chainType) {
+      switch (chainType) {
+        case AccountChainType.ETHEREUM:
+          types.push('ethereum');
+          break;
+        case AccountChainType.TON:
+          types.push('ton');
+          break;
+      }
+    } else {
+      if (isHex(phrase, 256)) {
+        types.push('ethereum');
+      } else if (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] = keyring.createFromUri(privateKey, {}, type).address;
+      });
+      rs.keyTypes = types;
+    } else {
+      rs.autoAddPrefix = false;
+      assert(false, t('Invalid private key'));
+    }
+    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;
+  }
+  privateKeyValidateV2({
+    chainType,
+    privateKey
+  }) {
+    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 = hexStripPrefix(secretKey);
+        if (_secret.length === 64) {
+          const suri = `0x${_secret}`;
+          const {
+            phrase
+          } = keyExtractSuri(suri);
+          if (isHex(phrase) && isHex(phrase, 256)) {
+            const type = 'ethereum';
+            keyringPair = keyring.createFromUri(suri, {
+              name: name
+            }, type);
+          }
+        }
+      } else {
+        keyringPair = keyring.keyring.createFromPair({
+          publicKey: hexToU8a(publicKey),
+          secretKey: hexToU8a(secretKey)
+        }, {
+          name
+        }, 'sr25519');
+      }
+      if (!keyringPair) {
+        return {
+          success: false,
+          errors: [{
+            code: AccountExternalErrorCode.KEYRING_ERROR,
+            message: t('Cannot create account')
+          }]
+        };
+      }
+      const _address = keyringPair.address;
+      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) || ''
+        }
+      }));
+      const nameExists = this.state.checkNameExists(name);
+      assert(!nameExists, new SWCommonAccountError(CommonAccountErrorType.ACCOUNT_NAME_EXISTED).message);
+      const modifyPairs = this.state.modifyPairs;
+      modifyPairs[_address] = {
+        migrated: true,
+        key: _address
+      };
+      this.state.upsertModifyPairs(modifyPairs);
+      keyring.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: AccountExternalErrorCode.KEYRING_ERROR,
+          message: e.message
+        }]
+      };
+    }
+  }
+  checkPublicAndSecretKey({
+    publicKey,
+    secretKey
+  }) {
+    let response = {
+      address: '',
+      isValid: true,
+      isEthereum: false
+    };
+    try {
+      const _secret = hexStripPrefix(secretKey);
+      if (_secret.length === 64) {
+        const suri = `0x${_secret}`;
+        const {
+          phrase
+        } = keyExtractSuri(suri);
+        if (isHex(phrase) && isHex(phrase, 256)) {
+          const type = 'ethereum';
+          const address = keyring.createFromUri(suri, {}, type).address;
+          response = {
+            address: address,
+            isValid: true,
+            isEthereum: true
+          };
+        } else {
+          response = {
+            address: '',
+            isValid: false,
+            isEthereum: true
+          };
+        }
+      } else {
+        const keyPair = keyring.keyring.createFromPair({
+          publicKey: hexToU8a(publicKey),
+          secretKey: hexToU8a(secretKey)
+        }, {}, 'sr25519');
+        response = {
+          address: keyPair.address,
+          isValid: true,
+          isEthereum: false
+        };
+      }
+    } catch (e) {
+      console.error(e);
+      return {
+        address: '',
+        isValid: false,
+        isEthereum: false,
+        errorMessage: t(e.message)
+      };
+    }
+    if (response.isValid) {
+      const exists = this.state.checkAddressExists([response.address]);
+      if (exists) {
+        response.errorMessage = 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 = keyring.backupAccount(keyring.getPair(address), password);
+    const decoded = decodePair(password, base64Decode(exportedJson.encoded), exportedJson.encoding.type);
+    return {
+      privateKey: u8aToHex(decoded.secretKey),
+      publicKey: u8aToHex(decoded.publicKey)
+    };
+  }
+}

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

@@ -0,0 +1,7 @@
+export * from './Derive';
+export * from './Inject';
+export * from './Json';
+export * from './Ledger';
+export * from './Mnemonic';
+export * from './Modify';
+export * from './Secret';

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

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./Derive.js";
+export * from "./Inject.js";
+export * from "./Json.js";
+export * from "./Ledger.js";
+export * from "./Mnemonic.js";
+export * from "./Modify.js";
+export * from "./Secret.js";

package/services/keyring-service/context/state.d.ts

@@ -0,0 +1,92 @@
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { AccountProxy, AccountProxyData, AccountProxyMap, AccountProxyStoreData, CurrentAccountInfo, ModifyPairStoreData } from '@subwallet/extension-base/types';
+import { SubjectInfo } from '@subwallet/ui-keyring/observable/types';
+interface ExistsAccount {
+    address: string;
+    name: string;
+}
+export declare class AccountState {
+    private readonly koniState;
+    private readonly _currentAccount;
+    private readonly _accountProxy;
+    private readonly _modifyPair;
+    private readonly contactSubject;
+    private readonly pairSubject;
+    private readonly accountSubject;
+    private readonly accountRefStore;
+    private beforeAccount;
+    private _injected;
+    constructor(koniState: KoniState);
+    private subscribeAccounts;
+    get injected(): boolean;
+    setInjected(injected: boolean): void;
+    get pairs(): SubjectInfo;
+    get contacts(): SubjectInfo;
+    get accounts(): AccountProxyMap;
+    get accountProxies(): AccountProxyStoreData;
+    get modifyPairs(): ModifyPairStoreData;
+    get value(): {
+        readonly pairs: SubjectInfo;
+        readonly accounts: AccountProxyMap;
+        readonly accountProxy: AccountProxyStoreData;
+        readonly currentAccount: CurrentAccountInfo;
+        readonly contacts: SubjectInfo;
+        readonly modifyPair: ModifyPairStoreData;
+    };
+    get observable(): {
+        readonly pairs: import("rxjs").Observable<SubjectInfo>;
+        readonly accounts: import("rxjs").Observable<AccountProxyMap>;
+        readonly accountProxy: import("rxjs").Observable<AccountProxyStoreData>;
+        readonly currentAccount: import("rxjs").Observable<CurrentAccountInfo>;
+        readonly contacts: import("rxjs").Observable<SubjectInfo>;
+    };
+    get currentAccount(): CurrentAccountInfo;
+    private setCurrentAccount;
+    /**
+     * Updates the current account proxy ID and emits an event to notify about the update.
+     * For case the proxy ID is set as `ALL_ACCOUNT_KEY`, it will be updated to the first account proxy ID if there is only one account.
+     *
+     * Note: This function should be called after account data is updated.
+     *
+     * @param _proxyId - The proxy ID to be set as the current account proxy ID.
+     * @param callback - Optional callback function to be executed after the current account proxy ID is updated.
+     * @param preventOneAccount - Optional flag to prevent setting the proxy ID if there is only one account.
+     */
+    saveCurrentAccountProxyId(_proxyId: string, callback?: (data: CurrentAccountInfo) => void, preventOneAccount?: boolean): void;
+    checkAddressExists(addresses: string[]): ExistsAccount | undefined;
+    checkNameExists(name: string, proxyId?: string): boolean;
+    getDuplicateAccountNames: (accounts: AccountProxy[]) => string[];
+    _addAddressesToAuthList(addresses: string[], isAllowed: boolean): void;
+    changeAddressAllowedAuthList(oldAddress: string, newAddress: string): void;
+    _addAddressToAuthList(address: string, isAllowed: boolean): void;
+    upsertAccountProxy(data: AccountProxyStoreData, callback?: () => void): void;
+    upsertAccountProxyByKey(data: AccountProxyData, callback?: () => void): void;
+    deleteAccountProxy(key: string, callback?: () => void): void;
+    isUnifiedAccount(proxyId: string): boolean;
+    belongUnifiedAccount(address: string): string | undefined;
+    addressesByProxyId(proxyId: string): string[];
+    upsertModifyPairs(data: ModifyPairStoreData): void;
+    getAllAddresses(): string[];
+    getProxyId(): string | null;
+    getDecodedAddresses(accountProxy?: string, allowGetAllAccount?: boolean): string[];
+    /**
+     * Account ref
+     * @deprecated
+     * */
+    /** @deprecated */
+    getAccountRefMap(callback: (refMap: Record<string, Array<string>>) => void): void;
+    /** @deprecated */
+    addAccountRef(addresses: string[], callback: () => void): void;
+    /** @deprecated */
+    removeAccountRef(address: string, callback: () => void): void;
+    /**
+     * Account ref
+     * */
+    removeNoneHardwareGenesisHash(): void;
+    updateMetadataForPair(): void;
+    updateMetadataForProxy(): void;
+    findNetworkKeyByGenesisHash(genesisHash?: string): string | undefined;
+    enableChain(slug: string): void;
+    resetWallet(): void;
+}
+export {};