@subwallet/extension-base 1.1.68-2 → 1.2.1

package/background/handlers/Extension.js

@@ -1,601 +0,0 @@
-// Copyright 2019-2022 @polkadot/extension authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { ALLOWED_PATH, PASSWORD_EXPIRY_MS } from '@subwallet/extension-base/defaults';
-import keyring from '@subwallet/ui-keyring';
-import { accounts as accountsObservable } from '@subwallet/ui-keyring/observable/accounts';
-import { TypeRegistry } from '@polkadot/types';
-import { assert, isHex } from '@polkadot/util';
-import { keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
-import { withErrorLog } from "./helpers.js";
-import { createSubscription, unsubscribe } from "./subscriptions.js";
-export const SEED_DEFAULT_LENGTH = 12;
-export const SEED_LENGTHS = [12, 15, 18, 21, 24];
-export const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
-
-// a global registry to use internally
-const registry = new TypeRegistry();
-export function getSuri(seed, type) {
-  return type === 'ethereum' ? `${seed}${ETH_DERIVE_DEFAULT}` : seed;
-}
-function transformAccounts(accounts) {
-  return Object.values(accounts).map(({
-    json: {
-      address,
-      meta
-    },
-    type
-  }) => ({
-    address,
-    ...meta,
-    type
-  }));
-}
-export function isJsonPayload(value) {
-  return value.genesisHash !== undefined;
-}
-export default class Extension {
-  #state;
-  constructor(state) {
-    this.cachedUnlocks = {};
-    this.#state = state;
-  }
-  accountsCreateExternal({
-    address,
-    genesisHash,
-    name
-  }) {
-    keyring.addExternal(address, {
-      genesisHash,
-      name
-    });
-    return true;
-  }
-  accountsCreateHardware({
-    accountIndex,
-    address,
-    addressOffset,
-    genesisHash,
-    hardwareType,
-    name
-  }) {
-    keyring.addHardware(address, hardwareType, {
-      accountIndex,
-      addressOffset,
-      genesisHash,
-      name
-    });
-    return true;
-  }
-  accountsCreateSuri({
-    genesisHash,
-    name,
-    suri,
-    type
-  }) {
-    keyring.addUri(getSuri(suri, type), {
-      genesisHash,
-      name
-    }, type);
-    return true;
-  }
-  accountsChangePassword({
-    address,
-    newPass,
-    oldPass
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find account');
-    try {
-      if (!pair.isLocked) {
-        pair.lock();
-      }
-      pair.decodePkcs8(oldPass);
-    } catch (error) {
-      throw new Error('Wrong password');
-    }
-    keyring.encryptAccount(pair, newPass);
-    return true;
-  }
-  accountsEdit({
-    address,
-    name
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find account');
-    keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      name
-    });
-    return true;
-  }
-  accountsExport({
-    address,
-    password
-  }) {
-    return {
-      exportedJson: keyring.backupAccount(keyring.getPair(address), password)
-    };
-  }
-
-  // private async accountsBatchExport ({ addresses, password }: RequestAccountBatchExport): Promise<ResponseAccountsExport> {
-  //   return {
-  //     exportedJson: await keyring.backupAccounts(addresses, password)
-  //   };
-  // }
-
-  accountsForget({
-    address
-  }) {
-    keyring.forgetAccount(address);
-    return true;
-  }
-  refreshAccountPasswordCache(pair) {
-    const {
-      address
-    } = pair;
-    const savedExpiry = this.cachedUnlocks[address] || 0;
-    const remainingTime = savedExpiry - Date.now();
-    if (remainingTime < 0) {
-      this.cachedUnlocks[address] = 0;
-      pair.lock();
-      return 0;
-    }
-    return remainingTime;
-  }
-  accountsShow({
-    address,
-    isShowing
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find account');
-    keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      isHidden: !isShowing
-    });
-    return true;
-  }
-  accountsTie({
-    address,
-    genesisHash
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find account');
-    keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      genesisHash
-    });
-    return true;
-  }
-  accountsValidate({
-    address,
-    password
-  }) {
-    try {
-      keyring.backupAccount(keyring.getPair(address), password);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  // FIXME This looks very much like what we have in Tabs
-  accountsSubscribe(id, port) {
-    const cb = createSubscription(id, port);
-    const subscription = accountsObservable.subject.subscribe(accounts => cb(transformAccounts(accounts)));
-    port.onDisconnect.addListener(() => {
-      unsubscribe(id);
-      subscription.unsubscribe();
-    });
-    return transformAccounts(accountsObservable.subject.getValue());
-  }
-  authorizeApprove({
-    id
-  }) {
-    const queued = this.#state.getAuthRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      resolve
-    } = queued;
-    resolve(true);
-    return true;
-  }
-  getAuthList() {
-    return {
-      list: this.#state.authUrls
-    };
-  }
-  authorizeReject({
-    id
-  }) {
-    const queued = this.#state.getAuthRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      reject
-    } = queued;
-    reject(new Error('Rejected'));
-    return true;
-  }
-
-  // FIXME This looks very much like what we have in accounts
-  authorizeSubscribe(id, port) {
-    const cb = createSubscription(id, port);
-    const subscription = this.#state.authSubject.subscribe(requests => cb(requests));
-    port.onDisconnect.addListener(() => {
-      unsubscribe(id);
-      subscription.unsubscribe();
-    });
-    return true;
-  }
-  metadataApprove({
-    id
-  }) {
-    const queued = this.#state.getMetaRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      request,
-      resolve
-    } = queued;
-    this.#state.saveMetadata(request);
-    resolve(true);
-    return true;
-  }
-  metadataGet(genesisHash) {
-    return this.#state.knownMetadata.find(result => result.genesisHash === genesisHash) || null;
-  }
-  metadataList() {
-    return this.#state.knownMetadata;
-  }
-  metadataReject({
-    id
-  }) {
-    const queued = this.#state.getMetaRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      reject
-    } = queued;
-    reject(new Error('Rejected'));
-    return true;
-  }
-  metadataSubscribe(id, port) {
-    const cb = createSubscription(id, port);
-    const subscription = this.#state.metaSubject.subscribe(requests => cb(requests));
-    port.onDisconnect.addListener(() => {
-      unsubscribe(id);
-      subscription.unsubscribe();
-    });
-    return this.#state.metaSubject.value;
-  }
-  jsonRestore({
-    file,
-    password
-  }) {
-    try {
-      keyring.restoreAccount(file, password, true);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  batchRestore({
-    file,
-    password
-  }) {
-    try {
-      keyring.restoreAccounts(file, password);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  jsonGetAccountInfo(json) {
-    try {
-      const {
-        address,
-        meta: {
-          genesisHash,
-          name
-        },
-        type
-      } = keyring.createFromJson(json);
-      return {
-        address,
-        genesisHash,
-        name,
-        type
-      };
-    } catch (e) {
-      console.error(e);
-      throw new Error(e.message);
-    }
-  }
-  seedCreate({
-    length = SEED_DEFAULT_LENGTH,
-    seed: _seed,
-    type
-  }) {
-    const seed = _seed || mnemonicGenerate(length);
-    return {
-      address: keyring.createFromUri(getSuri(seed, type), {}, type).address,
-      seed
-    };
-  }
-  seedValidate({
-    suri,
-    type
-  }) {
-    const {
-      phrase
-    } = keyExtractSuri(suri);
-    if (isHex(phrase)) {
-      assert(isHex(phrase, 256), '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), `Mnemonic needs to contain ${SEED_LENGTHS.join(', ')} words`);
-      assert(mnemonicValidate(phrase), 'Invalid seed phrase. Please try again.');
-    }
-    return {
-      address: keyring.createFromUri(getSuri(suri, type), {}, type).address,
-      suri
-    };
-  }
-  signingApprovePassword({
-    id,
-    password,
-    savePass
-  }) {
-    const queued = this.#state.getSignRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      reject,
-      request,
-      resolve
-    } = queued;
-    const pair = keyring.getPair(queued.account.address);
-
-    // unlike queued.account.address the following
-    // address is encoded with the default prefix
-    // which what is used for password caching mapping
-    const {
-      address
-    } = pair;
-    if (!pair) {
-      reject(new Error('Unable to find account'));
-      return false;
-    }
-    this.refreshAccountPasswordCache(pair);
-
-    // if the keyring pair is locked, the password is needed
-    if (pair.isLocked && !password) {
-      reject(new Error('Password needed to unlock the account'));
-    }
-    if (pair.isLocked) {
-      pair.decodePkcs8(password);
-    }
-    const {
-      payload
-    } = request;
-    if (isJsonPayload(payload)) {
-      // Get the metadata for the genesisHash
-      const currentMetadata = this.#state.knownMetadata.find(meta => meta.genesisHash === payload.genesisHash);
-
-      // set the registry before calling the sign function
-      registry.setSignedExtensions(payload.signedExtensions, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.userExtensions);
-      if (currentMetadata) {
-        registry.register(currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.types);
-      }
-    }
-    const result = request.sign(registry, pair);
-    if (savePass) {
-      this.cachedUnlocks[address] = Date.now() + PASSWORD_EXPIRY_MS;
-    } else {
-      pair.lock();
-    }
-    resolve({
-      id,
-      ...result
-    });
-    return true;
-  }
-  signingApproveSignature({
-    id,
-    signature
-  }) {
-    const queued = this.#state.getSignRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      resolve
-    } = queued;
-    resolve({
-      id,
-      signature
-    });
-    return true;
-  }
-  signingCancel({
-    id
-  }) {
-    const queued = this.#state.getSignRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const {
-      reject
-    } = queued;
-    reject(new Error('Cancelled'));
-    return true;
-  }
-  signingIsLocked({
-    id
-  }) {
-    const queued = this.#state.getSignRequest(id);
-    assert(queued, 'Unable to proceed. Please try again');
-    const address = queued.request.payload.address;
-    const pair = keyring.getPair(address);
-    assert(pair, 'Unable to find account');
-    const remainingTime = this.refreshAccountPasswordCache(pair);
-    return {
-      isLocked: pair.isLocked,
-      remainingTime
-    };
-  }
-
-  // FIXME This looks very much like what we have in authorization
-  signingSubscribe(id, port) {
-    const cb = createSubscription(id, port);
-    const subscription = this.#state.signSubject.subscribe(requests => cb(requests));
-    port.onDisconnect.addListener(() => {
-      unsubscribe(id);
-      subscription.unsubscribe();
-    });
-    return this.#state.signSubject.value;
-  }
-  windowOpen({
-    allowedPath: path,
-    params,
-    subPath
-  }) {
-    let paramString = '';
-    if (params) {
-      paramString += '?';
-      for (let i = 0; i < Object.keys(params).length; i++) {
-        const [key, value] = Object.entries(params)[i];
-        paramString += `${key}=${value}`;
-        if (i !== Object.keys(params).length - 1) {
-          paramString += '&';
-        }
-      }
-    }
-    const url = `${chrome.extension.getURL('index.html')}#${path}${subPath || ''}${paramString}`;
-    if (!ALLOWED_PATH.includes(path)) {
-      console.error('Not allowed to open the url:', url);
-      return false;
-    }
-    withErrorLog(() => chrome.tabs.create({
-      url
-    }));
-    return true;
-  }
-  derive(parentAddress, suri, password, metadata) {
-    const parentPair = keyring.getPair(parentAddress);
-    try {
-      parentPair.decodePkcs8(password);
-    } catch (e) {
-      throw new Error('Wrong password');
-    }
-    try {
-      return parentPair.derive(suri, metadata);
-    } catch (err) {
-      throw new Error(`"${suri}" is not a valid derivation path`);
-    }
-  }
-  derivationValidate({
-    parentAddress,
-    parentPassword,
-    suri
-  }) {
-    const childPair = this.derive(parentAddress, suri, parentPassword, {});
-    return {
-      address: childPair.address,
-      suri
-    };
-  }
-  derivationCreate({
-    genesisHash,
-    name,
-    parentAddress,
-    parentPassword,
-    suri
-  }) {
-    const childPair = this.derive(parentAddress, suri, parentPassword, {
-      genesisHash,
-      name,
-      parentAddress,
-      suri
-    });
-    keyring.addPair(childPair, true);
-    return true;
-  }
-  toggleAuthorization(url) {
-    return {
-      list: this.#state.toggleAuthorization(url)
-    };
-  }
-
-  // Weird thought, the eslint override is not needed in Tabs
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async handle(id, type, request, port) {
-    switch (type) {
-      case 'pri(authorize.approve)':
-        return this.authorizeApprove(request);
-      case 'pri(authorize.list)':
-        return this.getAuthList();
-      case 'pri(authorize.reject)':
-        return this.authorizeReject(request);
-      case 'pri(authorize.toggle)':
-        return this.toggleAuthorization(request);
-      case 'pri(authorize.requests)':
-        return this.authorizeSubscribe(id, port);
-      case 'pri(accounts.create.external)':
-        return this.accountsCreateExternal(request);
-      case 'pri(accounts.create.hardware)':
-        return this.accountsCreateHardware(request);
-      case 'pri(accounts.create.suri)':
-        return this.accountsCreateSuri(request);
-      case 'pri(accounts.changePassword)':
-        return this.accountsChangePassword(request);
-      case 'pri(accounts.edit)':
-        return this.accountsEdit(request);
-      case 'pri(accounts.export)':
-        return this.accountsExport(request);
-      case 'pri(accounts.batchExport)':
-        // return this.accountsBatchExport(request as RequestAccountBatchExport);
-        // Disable export all util use master password
-        return null;
-      case 'pri(accounts.forget)':
-        return this.accountsForget(request);
-      case 'pri(accounts.show)':
-        return this.accountsShow(request);
-      case 'pri(accounts.subscribe)':
-        return this.accountsSubscribe(id, port);
-      case 'pri(accounts.tie)':
-        return this.accountsTie(request);
-      case 'pri(accounts.validate)':
-        return this.accountsValidate(request);
-      case 'pri(metadata.approve)':
-        return this.metadataApprove(request);
-      case 'pri(metadata.get)':
-        return this.metadataGet(request);
-      case 'pri(metadata.list)':
-        return this.metadataList();
-      case 'pri(metadata.reject)':
-        return this.metadataReject(request);
-      case 'pri(metadata.requests)':
-        return this.metadataSubscribe(id, port);
-      case 'pri(derivation.create)':
-        return this.derivationCreate(request);
-      case 'pri(derivation.validate)':
-        return this.derivationValidate(request);
-      case 'pri(json.restore)':
-        return this.jsonRestore(request);
-      case 'pri(json.batchRestore)':
-        return this.batchRestore(request);
-      case 'pri(json.account.info)':
-        return this.jsonGetAccountInfo(request);
-      case 'pri(seed.create)':
-        return this.seedCreate(request);
-      case 'pri(seed.validate)':
-        return this.seedValidate(request);
-      case 'pri(signing.approve.password)':
-        return this.signingApprovePassword(request);
-      case 'pri(signing.approve.signature)':
-        return this.signingApproveSignature(request);
-      case 'pri(signing.cancel)':
-        return this.signingCancel(request);
-      case 'pri(signing.isLocked)':
-        return this.signingIsLocked(request);
-      case 'pri(signing.requests)':
-        return this.signingSubscribe(id, port);
-      case 'pri(window.open)':
-        return this.windowOpen(request);
-      default:
-        throw new Error(`Unable to handle message of type ${type}`);
-    }
-  }
-}

package/background/handlers/Tabs.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="chrome" />
-import type { MessageTypes, RequestTypes, ResponseTypes } from '../types';
-import State from './State';
-export default class Tabs {
-    #private;
-    constructor(state: State);
-    private authorize;
-    private accountsList;
-    private accountsSubscribe;
-    private getSigningPair;
-    private bytesSign;
-    private extrinsicSign;
-    private metadataProvide;
-    private metadataList;
-    private rpcListProviders;
-    private rpcSend;
-    private rpcStartProvider;
-    private rpcSubscribe;
-    private rpcSubscribeConnected;
-    private rpcUnsubscribe;
-    private redirectPhishingLanding;
-    protected redirectIfPhishing(url: string): Promise<boolean>;
-    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
-}