@subwallet/extension-base 0.3.6-0

package/build/background/handlers/State.d.ts

@@ -0,0 +1,87 @@
+/// <reference types="chrome" />
+import type { MetadataDef, ProviderMeta } from '@subwallet/extension-inject/types';
+import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
+import type { AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning, SigningRequest } from '../types';
+import { BehaviorSubject } from 'rxjs';
+export interface Resolver<T> {
+    reject: (error: Error) => void;
+    resolve: (result: T) => void;
+}
+export interface AuthRequest extends Resolver<boolean> {
+    id: string;
+    idStr: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export declare type AuthUrls = Record<string, AuthUrlInfo>;
+export interface AuthUrlInfo {
+    count: number;
+    id: string;
+    isAllowed: boolean;
+    origin: string;
+    url: string;
+    isAllowedMap: Record<string, boolean>;
+}
+interface MetaRequest extends Resolver<boolean> {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+declare type Providers = Record<string, {
+    meta: ProviderMeta;
+    start: () => ProviderInterface;
+}>;
+interface SignRequest extends Resolver<ResponseSigning> {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export declare enum NotificationOptions {
+    None = 0,
+    Normal = 1,
+    PopUp = 2
+}
+export default class State {
+    #private;
+    readonly authSubject: BehaviorSubject<AuthorizeRequest[]>;
+    readonly metaSubject: BehaviorSubject<MetadataRequest[]>;
+    readonly signSubject: BehaviorSubject<SigningRequest[]>;
+    constructor(providers?: Providers);
+    get knownMetadata(): MetadataDef[];
+    get numAuthRequests(): number;
+    get numMetaRequests(): number;
+    get numSignRequests(): number;
+    get allAuthRequests(): AuthorizeRequest[];
+    get allMetaRequests(): MetadataRequest[];
+    get allSignRequests(): SigningRequest[];
+    get authUrls(): AuthUrls;
+    protected popupClose(): void;
+    protected popupOpen(): void;
+    private authComplete;
+    private saveCurrentAuthList;
+    private metaComplete;
+    private signComplete;
+    stripUrl(url: string): string;
+    private updateIcon;
+    toggleAuthorization(url: string): AuthUrls;
+    private updateIconAuth;
+    private updateIconMeta;
+    private updateIconSign;
+    authorizeUrl(url: string, request: RequestAuthorizeTab): Promise<boolean>;
+    ensureUrlAuthorized(url: string): boolean;
+    injectMetadata(url: string, request: MetadataDef): Promise<boolean>;
+    getAuthRequest(id: string): AuthRequest;
+    getMetaRequest(id: string): MetaRequest;
+    getSignRequest(id: string): SignRequest;
+    rpcListProviders(): Promise<ResponseRpcListProviders>;
+    rpcSend(request: RequestRpcSend, port: chrome.runtime.Port): Promise<JsonRpcResponse>;
+    rpcStartProvider(key: string, port: chrome.runtime.Port): Promise<ProviderMeta>;
+    rpcSubscribe({ method, params, type }: RequestRpcSubscribe, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): Promise<number | string>;
+    rpcSubscribeConnected(_request: null, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): void;
+    rpcUnsubscribe(request: RequestRpcUnsubscribe, port: chrome.runtime.Port): Promise<boolean>;
+    saveMetadata(meta: MetadataDef): void;
+    setNotification(notification: string): boolean;
+    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+}
+export {};

package/build/background/handlers/State.js

@@ -0,0 +1,434 @@
+// Copyright 2019-2022 @subwallet/extension-bg authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getId } from '@subwallet/extension-base/utils/getId';
+import { addMetadata, knownMetadata } from '@subwallet/extension-chains';
+import { BehaviorSubject } from 'rxjs';
+import { knownGenesis } from '@polkadot/networks/defaults';
+import settings from '@polkadot/ui-settings';
+import { assert } from '@polkadot/util';
+import { MetadataStore } from "../../stores/index.js";
+import { withErrorLog } from "./helpers.js";
+const NOTIFICATION_URL = chrome.extension.getURL('notification.html');
+const POPUP_WINDOW_OPTS = {
+  focused: true,
+  height: 621,
+  left: 150,
+  top: 150,
+  type: 'popup',
+  url: NOTIFICATION_URL,
+  width: 460
+};
+const NORMAL_WINDOW_OPTS = {
+  focused: true,
+  type: 'normal',
+  url: NOTIFICATION_URL
+};
+export let NotificationOptions;
+
+(function (NotificationOptions) {
+  NotificationOptions[NotificationOptions["None"] = 0] = "None";
+  NotificationOptions[NotificationOptions["Normal"] = 1] = "Normal";
+  NotificationOptions[NotificationOptions["PopUp"] = 2] = "PopUp";
+})(NotificationOptions || (NotificationOptions = {}));
+
+const AUTH_URLS_KEY = 'authUrls';
+
+function extractMetadata(store) {
+  store.allMap(map => {
+    const knownEntries = Object.entries(knownGenesis);
+    const defs = {};
+    const removals = [];
+    Object.entries(map).forEach(([key, def]) => {
+      const entry = knownEntries.find(([, hashes]) => hashes.includes(def.genesisHash));
+
+      if (entry) {
+        const [name, hashes] = entry;
+        const index = hashes.indexOf(def.genesisHash); // flatten the known metadata based on the genesis index
+        // (lower is better/newer)
+
+        if (!defs[name] || defs[name].index > index) {
+          if (defs[name]) {
+            // remove the old version of the metadata
+            removals.push(defs[name].key);
+          }
+
+          defs[name] = {
+            def,
+            index,
+            key
+          };
+        }
+      } else {
+        // this is not a known entry, so we will just apply it
+        defs[key] = {
+          def,
+          index: 0,
+          key
+        };
+      }
+    });
+    removals.forEach(key => store.remove(key));
+    Object.values(defs).forEach(({
+      def
+    }) => addMetadata(def));
+  });
+}
+
+export default class State {
+  #authUrls = {};
+  #authRequests = {};
+  #metaStore = new MetadataStore(); // Map of providers currently injected in tabs
+
+  #injectedProviders = new Map();
+  #metaRequests = {};
+  #notification = settings.notification; // Map of all providers exposed by the extension, they are retrievable by key
+
+  #providers;
+  #signRequests = {};
+  #windows = [];
+  authSubject = new BehaviorSubject([]);
+  metaSubject = new BehaviorSubject([]);
+  signSubject = new BehaviorSubject([]);
+
+  constructor(providers = {}) {
+    this.#providers = providers;
+    extractMetadata(this.#metaStore); // retrieve previously set authorizations
+
+    const authString = localStorage.getItem(AUTH_URLS_KEY) || '{}';
+    const previousAuth = JSON.parse(authString);
+    this.#authUrls = previousAuth;
+  }
+
+  get knownMetadata() {
+    return knownMetadata();
+  }
+
+  get numAuthRequests() {
+    return Object.keys(this.#authRequests).length;
+  }
+
+  get numMetaRequests() {
+    return Object.keys(this.#metaRequests).length;
+  }
+
+  get numSignRequests() {
+    return Object.keys(this.#signRequests).length;
+  }
+
+  get allAuthRequests() {
+    return Object.values(this.#authRequests).map(({
+      id,
+      request,
+      url
+    }) => ({
+      id,
+      request,
+      url
+    }));
+  }
+
+  get allMetaRequests() {
+    return Object.values(this.#metaRequests).map(({
+      id,
+      request,
+      url
+    }) => ({
+      id,
+      request,
+      url
+    }));
+  }
+
+  get allSignRequests() {
+    return Object.values(this.#signRequests).map(({
+      account,
+      id,
+      request,
+      url
+    }) => ({
+      account,
+      id,
+      request,
+      url
+    }));
+  }
+
+  get authUrls() {
+    return this.#authUrls;
+  }
+
+  popupClose() {
+    this.#windows.forEach(id => withErrorLog(() => chrome.windows.remove(id)));
+    this.#windows = [];
+  }
+
+  popupOpen() {
+    this.#notification !== 'extension' && chrome.windows.create(this.#notification === 'window' ? NORMAL_WINDOW_OPTS : POPUP_WINDOW_OPTS, window => {
+      if (window) {
+        this.#windows.push(window.id || 0);
+      }
+    });
+  }
+
+  authComplete = (id, resolve, reject) => {
+    const complete = result => {
+      const isAllowed = result === true;
+      const {
+        idStr,
+        request: {
+          origin
+        },
+        url
+      } = this.#authRequests[id];
+      const isAllowedMap = {};
+      this.#authUrls[this.stripUrl(url)] = {
+        count: 0,
+        id: idStr,
+        isAllowed,
+        isAllowedMap,
+        origin,
+        url
+      };
+      this.saveCurrentAuthList();
+      delete this.#authRequests[id];
+      this.updateIconAuth(true);
+    };
+
+    return {
+      reject: error => {
+        complete(error);
+        reject(error);
+      },
+      resolve: result => {
+        complete(result);
+        resolve(result);
+      }
+    };
+  };
+
+  saveCurrentAuthList() {
+    localStorage.setItem(AUTH_URLS_KEY, JSON.stringify(this.#authUrls));
+  }
+
+  metaComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#metaRequests[id];
+      this.updateIconMeta(true);
+    };
+
+    return {
+      reject: error => {
+        complete();
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+  signComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#signRequests[id];
+      this.updateIconSign(true);
+    };
+
+    return {
+      reject: error => {
+        complete();
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+
+  stripUrl(url) {
+    assert(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
+    const parts = url.split('/');
+    return parts[2];
+  }
+
+  updateIcon(shouldClose) {
+    const authCount = this.numAuthRequests;
+    const metaCount = this.numMetaRequests;
+    const signCount = this.numSignRequests;
+    const text = authCount ? 'Auth' : metaCount ? 'Meta' : signCount ? `${signCount}` : '';
+    withErrorLog(() => chrome.browserAction.setBadgeText({
+      text
+    }));
+
+    if (shouldClose && text === '') {
+      this.popupClose();
+    }
+  }
+
+  toggleAuthorization(url) {
+    const entry = this.#authUrls[url];
+    assert(entry, `The source ${url} is not known`);
+    this.#authUrls[url].isAllowed = !entry.isAllowed;
+    this.saveCurrentAuthList();
+    return this.#authUrls;
+  }
+
+  updateIconAuth(shouldClose) {
+    this.authSubject.next(this.allAuthRequests);
+    this.updateIcon(shouldClose);
+  }
+
+  updateIconMeta(shouldClose) {
+    this.metaSubject.next(this.allMetaRequests);
+    this.updateIcon(shouldClose);
+  }
+
+  updateIconSign(shouldClose) {
+    this.signSubject.next(this.allSignRequests);
+    this.updateIcon(shouldClose);
+  }
+
+  async authorizeUrl(url, request) {
+    const idStr = this.stripUrl(url); // Do not enqueue duplicate authorization requests.
+
+    const isDuplicate = Object.values(this.#authRequests).some(request => request.idStr === idStr);
+    assert(!isDuplicate, `The source ${url} has a pending authorization request`);
+
+    if (this.#authUrls[idStr]) {
+      // this url was seen in the past
+      assert(this.#authUrls[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
+      return false;
+    }
+
+    return new Promise((resolve, reject) => {
+      const id = getId();
+      this.#authRequests[id] = { ...this.authComplete(id, resolve, reject),
+        id,
+        idStr,
+        request,
+        url
+      };
+      this.updateIconAuth();
+      this.popupOpen();
+    });
+  }
+
+  ensureUrlAuthorized(url) {
+    const entry = this.#authUrls[this.stripUrl(url)];
+    assert(entry, `The source ${url} has not been enabled yet`);
+    assert(entry.isAllowed, `The source ${url} is not allowed to interact with this extension`);
+    return true;
+  }
+
+  injectMetadata(url, request) {
+    return new Promise((resolve, reject) => {
+      const id = getId();
+      this.#metaRequests[id] = { ...this.metaComplete(id, resolve, reject),
+        id,
+        request,
+        url
+      };
+      this.updateIconMeta();
+      this.popupOpen();
+    });
+  }
+
+  getAuthRequest(id) {
+    return this.#authRequests[id];
+  }
+
+  getMetaRequest(id) {
+    return this.#metaRequests[id];
+  }
+
+  getSignRequest(id) {
+    return this.#signRequests[id];
+  } // List all providers the extension is exposing
+
+
+  rpcListProviders() {
+    return Promise.resolve(Object.keys(this.#providers).reduce((acc, key) => {
+      acc[key] = this.#providers[key].meta;
+      return acc;
+    }, {}));
+  }
+
+  rpcSend(request, port) {
+    const provider = this.#injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
+    return provider.send(request.method, request.params);
+  } // Start a provider, return its meta
+
+
+  rpcStartProvider(key, port) {
+    assert(Object.keys(this.#providers).includes(key), `Provider ${key} is not exposed by extension`);
+
+    if (this.#injectedProviders.get(port)) {
+      return Promise.resolve(this.#providers[key].meta);
+    } // Instantiate the provider
+
+
+    this.#injectedProviders.set(port, this.#providers[key].start()); // Close provider connection when page is closed
+
+    port.onDisconnect.addListener(() => {
+      const provider = this.#injectedProviders.get(port);
+
+      if (provider) {
+        withErrorLog(() => provider.disconnect());
+      }
+
+      this.#injectedProviders.delete(port);
+    });
+    return Promise.resolve(this.#providers[key].meta);
+  }
+
+  rpcSubscribe({
+    method,
+    params,
+    type
+  }, cb, port) {
+    const provider = this.#injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
+    return provider.subscribe(type, method, params, cb);
+  }
+
+  rpcSubscribeConnected(_request, cb, port) {
+    const provider = this.#injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribeConnected) before provider is set');
+    cb(null, provider.isConnected); // Immediately send back current isConnected
+
+    provider.on('connected', () => cb(null, true));
+    provider.on('disconnected', () => cb(null, false));
+  }
+
+  rpcUnsubscribe(request, port) {
+    const provider = this.#injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.unsubscribe) before provider is set');
+    return provider.unsubscribe(request.type, request.method, request.subscriptionId);
+  }
+
+  saveMetadata(meta) {
+    this.#metaStore.set(meta.genesisHash, meta);
+    addMetadata(meta);
+  }
+
+  setNotification(notification) {
+    this.#notification = notification;
+    return true;
+  }
+
+  sign(url, request, account) {
+    const id = getId();
+    return new Promise((resolve, reject) => {
+      this.#signRequests[id] = { ...this.signComplete(id, resolve, reject),
+        account,
+        id,
+        request,
+        url
+      };
+      this.updateIconSign();
+      this.popupOpen();
+    });
+  }
+
+}

package/build/background/handlers/Tabs.d.ts

@@ -0,0 +1,24 @@
+/// <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]>;
+}