@subwallet/extension-base 0.8.3-2 → 1.0.1

package/services/request-service/handler/SubstrateRequestHandler.js

@@ -0,0 +1,94 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import { isInternalRequest } from '@subwallet/extension-base/utils/request';
+import keyring from '@subwallet/ui-keyring';
+import { BehaviorSubject } from 'rxjs';
+import { logger as createLogger } from '@polkadot/util/logger';
+export default class SubstrateRequestHandler {
+  #logger;
+  #requestService;
+  #substrateRequests = {};
+  signSubject = new BehaviorSubject([]);
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = createLogger('SubstrateRequestHandler');
+  }
+  getSignRequest(id) {
+    return this.#substrateRequests[id];
+  }
+  get allSubstrateRequests() {
+    return Object.values(this.#substrateRequests).map(({
+      account,
+      id,
+      request,
+      url
+    }) => ({
+      account,
+      id,
+      request,
+      url,
+      isInternal: isInternalRequest(url)
+    }));
+  }
+  updateIconSign(shouldClose) {
+    this.signSubject.next(this.allSubstrateRequests);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  signComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#substrateRequests[id];
+      this.updateIconSign(true);
+    };
+    return {
+      reject: error => {
+        complete();
+        this.#logger.log(error);
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+  get numSubstrateRequests() {
+    return Object.keys(this.#substrateRequests).length;
+  }
+  sign(url, request, account) {
+    const id = getId();
+    return new Promise((resolve, reject) => {
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        account,
+        id,
+        request,
+        url
+      };
+      this.updateIconSign();
+      this.#requestService.popupOpen();
+    });
+  }
+  signTransaction(id, address, url, payload) {
+    return new Promise((resolve, reject) => {
+      const pair = keyring.getPair(address);
+      const account = {
+        address: pair.address,
+        ...pair.meta
+      };
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        account,
+        id,
+        request: new RequestExtrinsicSign(payload),
+        url: url
+      };
+      this.updateIconSign();
+      if (!isInternalRequest(url)) {
+        this.#requestService.popupOpen();
+      }
+    });
+  }
+}

package/services/request-service/helper/index.d.ts

@@ -0,0 +1,4 @@
+import { MetadataStore } from '@subwallet/extension-base/stores';
+import { OSType } from '../types';
+export declare const extractMetadata: (store: MetadataStore) => void;
+export declare const getOS: () => OSType;

package/services/request-service/helper/index.js

@@ -0,0 +1,67 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { addMetadata } from '@subwallet/extension-chains';
+import { knownGenesis } from '@polkadot/networks/defaults';
+export const 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 const getOS = () => {
+  var _window$navigator, _window$navigator$use;
+  const userAgent = window.navigator.userAgent;
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const platform = ((_window$navigator = window.navigator) === null || _window$navigator === void 0 ? void 0 : (_window$navigator$use = _window$navigator.userAgentData) === null || _window$navigator$use === void 0 ? void 0 : _window$navigator$use.platform) || window.navigator.platform;
+  const macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
+  const windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
+  const iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+  let os = 'Unknown';
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = 'Mac OS';
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = 'iOS';
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = 'Windows';
+  } else if (/Android/.test(userAgent)) {
+    os = 'Android';
+  } else if (/Linux/.test(platform)) {
+    os = 'Linux';
+  }
+  return os;
+};

package/services/request-service/index.d.ts

@@ -0,0 +1,46 @@
+import { AuthRequestV2, ConfirmationDefinitions, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationType, RequestConfirmationComplete } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { AuthUrls, MetaRequest } from '@subwallet/extension-base/services/request-service/types';
+import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import { MetadataDef } from '@subwallet/extension-inject/types';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { SignerPayloadJSON } from '@polkadot/types/types/extrinsic';
+export default class RequestService {
+    #private;
+    readonly settingService: SettingService;
+    constructor(chainService: ChainService, settingService: SettingService);
+    get numAllRequests(): number;
+    updateIconV2(shouldClose?: boolean): void;
+    getAddressList(value?: boolean): Record<string, boolean>;
+    get popup(): number[];
+    popupClose(): void;
+    popupOpen(): void;
+    get metaSubject(): BehaviorSubject<MetadataRequest[]>;
+    get knownMetadata(): MetadataDef[];
+    get numMetaRequests(): number;
+    injectMetadata(url: string, request: MetadataDef): Promise<boolean>;
+    getMetaRequest(id: string): MetaRequest;
+    saveMetadata(meta: MetadataDef): void;
+    get authSubjectV2(): BehaviorSubject<AuthorizeRequest[]>;
+    get numAuthRequests(): number;
+    setAuthorize(data: AuthUrls, callback?: () => void): void;
+    getAuthorize(update: (value: AuthUrls) => void): void;
+    getAuthList(): Promise<AuthUrls>;
+    authorizeUrlV2(url: string, request: RequestAuthorizeTab): Promise<boolean>;
+    getAuthRequestV2(id: string): AuthRequestV2;
+    get subscribeEvmChainChange(): Subject<AuthUrls>;
+    get subscribeAuthorizeUrlSubject(): Subject<AuthUrls>;
+    ensureUrlAuthorizedV2(url: string): Promise<boolean>;
+    get signSubject(): BehaviorSubject<SigningRequest[]>;
+    get allSubstrateRequests(): SigningRequest[];
+    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+    get numSubstrateRequests(): number;
+    get numEvmRequests(): number;
+    get confirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
+    getSignRequest(id: string): import("@subwallet/extension-base/services/request-service/types").SignRequest | undefined;
+    signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON): Promise<ResponseSigning>;
+    addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
+    completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
+    get numRequests(): number;
+}

package/services/request-service/index.js

@@ -0,0 +1,147 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import AuthRequestHandler from '@subwallet/extension-base/services/request-service/handler/AuthRequestHandler';
+import EvmRequestHandler from '@subwallet/extension-base/services/request-service/handler/EvmRequestHandler';
+import MetadataRequestHandler from '@subwallet/extension-base/services/request-service/handler/MetadataRequestHandler';
+import PopupHandler from '@subwallet/extension-base/services/request-service/handler/PopupHandler';
+import SubstrateRequestHandler from '@subwallet/extension-base/services/request-service/handler/SubstrateRequestHandler';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+export default class RequestService {
+  // Common
+  #chainService;
+  #popupHandler;
+  #metadataRequestHandler;
+  #authRequestHandler;
+  #substrateRequestHandler;
+  #evmRequestHandler;
+
+  // Common
+  constructor(chainService, settingService) {
+    this.#chainService = chainService;
+    this.settingService = settingService;
+    this.#popupHandler = new PopupHandler(this);
+    this.#metadataRequestHandler = new MetadataRequestHandler(this);
+    this.#authRequestHandler = new AuthRequestHandler(this, this.#chainService);
+    this.#substrateRequestHandler = new SubstrateRequestHandler(this);
+    this.#evmRequestHandler = new EvmRequestHandler(this);
+
+    // Reset icon on start service
+    this.updateIconV2();
+  }
+  get numAllRequests() {
+    return this.allSubstrateRequests.length + this.numEvmRequests;
+  }
+  updateIconV2(shouldClose) {
+    this.#popupHandler.updateIconV2(shouldClose);
+  }
+  getAddressList(value = false) {
+    const addressList = Object.keys(accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+
+  // Popup
+  get popup() {
+    return this.#popupHandler.popup;
+  }
+  popupClose() {
+    this.#popupHandler.popupClose();
+  }
+  popupOpen() {
+    this.#popupHandler.popupOpen();
+  }
+
+  // Metadata
+  get metaSubject() {
+    return this.#metadataRequestHandler.metaSubject;
+  }
+  get knownMetadata() {
+    return this.#metadataRequestHandler.knownMetadata;
+  }
+  get numMetaRequests() {
+    return this.#metadataRequestHandler.numMetaRequests;
+  }
+  injectMetadata(url, request) {
+    return this.#metadataRequestHandler.injectMetadata(url, request);
+  }
+  getMetaRequest(id) {
+    return this.#metadataRequestHandler.getMetaRequest(id);
+  }
+  saveMetadata(meta) {
+    this.#metadataRequestHandler.saveMetadata(meta);
+  }
+
+  // Auth
+  get authSubjectV2() {
+    return this.#authRequestHandler.authSubjectV2;
+  }
+  get numAuthRequests() {
+    return this.#authRequestHandler.numAuthRequestsV2;
+  }
+  setAuthorize(data, callback) {
+    this.#authRequestHandler.setAuthorize(data, callback);
+  }
+  getAuthorize(update) {
+    this.#authRequestHandler.getAuthorize(update);
+  }
+  getAuthList() {
+    return this.#authRequestHandler.getAuthList();
+  }
+  async authorizeUrlV2(url, request) {
+    return this.#authRequestHandler.authorizeUrlV2(url, request);
+  }
+  getAuthRequestV2(id) {
+    return this.#authRequestHandler.getAuthRequestV2(id);
+  }
+  get subscribeEvmChainChange() {
+    return this.#authRequestHandler.subscribeEvmChainChange;
+  }
+  get subscribeAuthorizeUrlSubject() {
+    return this.#authRequestHandler.subscribeAuthorizeUrlSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    return this.#authRequestHandler.ensureUrlAuthorizedV2(url);
+  }
+
+  // Substrate requests
+  get signSubject() {
+    return this.#substrateRequestHandler.signSubject;
+  }
+  get allSubstrateRequests() {
+    return this.#substrateRequestHandler.allSubstrateRequests;
+  }
+  sign(url, request, account) {
+    return this.#substrateRequestHandler.sign(url, request, account);
+  }
+  get numSubstrateRequests() {
+    return this.#substrateRequestHandler.numSubstrateRequests;
+  }
+
+  // Evm requests
+  get numEvmRequests() {
+    return this.#evmRequestHandler.numEvmRequests;
+  }
+  get confirmationsQueueSubject() {
+    return this.#evmRequestHandler.getConfirmationsQueueSubject();
+  }
+  getSignRequest(id) {
+    return this.#substrateRequestHandler.getSignRequest(id);
+  }
+  async signInternalTransaction(id, address, url, payload) {
+    return this.#substrateRequestHandler.signTransaction(id, address, url, payload);
+  }
+  addConfirmation(id, url, type, payload, options = {}, validator) {
+    return this.#evmRequestHandler.addConfirmation(id, url, type, payload, options, validator);
+  }
+  async completeConfirmation(request) {
+    return await this.#evmRequestHandler.completeConfirmation(request);
+  }
+
+  // General methods
+  get numRequests() {
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests;
+  }
+}

package/services/request-service/types.d.ts

@@ -0,0 +1,25 @@
+import { AccountAuthType, AccountJson, RequestSign, Resolver, ResponseSigning } from '@subwallet/extension-base/background/types';
+import { MetadataDef } from '@subwallet/extension-inject/types';
+export interface SignRequest extends Resolver<ResponseSigning> {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export interface MetaRequest extends Resolver<boolean> {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+export interface AuthUrlInfo {
+    count: number;
+    id: string;
+    isAllowed: boolean;
+    origin: string;
+    url: string;
+    accountAuthType?: AccountAuthType;
+    isAllowedMap: Record<string, boolean>;
+    currentEvmNetworkKey?: string;
+}
+export declare type AuthUrls = Record<string, AuthUrlInfo>;
+export declare type OSType = 'Mac OS' | 'iOS' | 'Windows' | 'Android' | 'Linux' | 'Unknown';

package/services/request-service/types.js

@@ -0,0 +1 @@
+export {};

package/services/setting-service/SettingService.d.ts

@@ -0,0 +1,8 @@
+import { RequestSettingsType } from '@subwallet/extension-base/background/KoniTypes';
+import { Subject } from 'rxjs';
+export default class SettingService {
+    private readonly settingsStore;
+    getSubject(): Subject<RequestSettingsType>;
+    getSettings(update: (value: RequestSettingsType) => void): void;
+    setSettings(data: RequestSettingsType, callback?: () => void): void;
+}

package/services/setting-service/SettingService.js

@@ -0,0 +1,31 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import SettingsStore from '@subwallet/extension-base/stores/Settings';
+import { DEFAULT_NOTIFICATION_TYPE, DEFAULT_THEME } from "./constants.js";
+export default class SettingService {
+  settingsStore = new SettingsStore();
+  getSubject() {
+    return this.settingsStore.getSubject();
+  }
+  getSettings(update) {
+    this.settingsStore.get('Settings', value => {
+      if (!value) {
+        update({
+          // language: 'en',
+          browserConfirmationType: DEFAULT_NOTIFICATION_TYPE,
+          // isShowZeroBalance: true,
+          isShowBalance: false,
+          accountAllLogo: '',
+          theme: DEFAULT_THEME,
+          camera: false
+        });
+      } else {
+        update(value);
+      }
+    });
+  }
+  setSettings(data, callback) {
+    this.settingsStore.set('Settings', data, callback);
+  }
+}

package/services/setting-service/constants.d.ts

@@ -0,0 +1,3 @@
+import { BrowserConfirmationType, ThemeNames } from '@subwallet/extension-base/background/KoniTypes';
+export declare const DEFAULT_THEME: ThemeNames;
+export declare const DEFAULT_NOTIFICATION_TYPE: BrowserConfirmationType;

package/services/setting-service/constants.js

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ThemeNames } from '@subwallet/extension-base/background/KoniTypes';
+export const DEFAULT_THEME = ThemeNames.DARK;
+export const DEFAULT_NOTIFICATION_TYPE = 'popup';

package/services/storage-service/DatabaseService.d.ts

@@ -0,0 +1,64 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { BalanceItem, ChainStakingMetadata, CrowdloanItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, StakingType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { IBalance, IChain, INft } from '@subwallet/extension-base/services/storage-service/databases';
+import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
+import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
+import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
+import { HistoryQuery } from '@subwallet/extension-base/services/storage-service/db-stores/Transaction';
+import { Subscription } from 'dexie';
+export default class DatabaseService {
+    private _db;
+    stores: {
+        price: PriceStore;
+        balance: BalanceStore;
+        nft: NftStore;
+        nftCollection: NftCollectionStore;
+        crowdloan: CrowdloanStore;
+        staking: StakingStore;
+        transaction: TransactionStore;
+        migration: MigrationStore;
+        chain: ChainStore;
+        asset: AssetStore;
+        chainStakingMetadata: ChainStakingMetadataStore;
+        nominatorMetadata: NominatorMetadataStore;
+    };
+    private logger;
+    private nftSubscription;
+    private stakingSubscription;
+    constructor();
+    updatePriceStore(priceData: PriceJson): Promise<void>;
+    getPriceStore(): Promise<PriceJson | undefined>;
+    getStoredBalance(): Promise<IBalance[]>;
+    updateBalanceStore(address: string, item: BalanceItem): Promise<unknown>;
+    removeFromBalanceStore(assets: string[]): Promise<number>;
+    updateCrowdloanStore(chain: string, address: string, item: CrowdloanItem): Promise<unknown>;
+    updateStaking(chain: string, address: string, item: StakingItem): Promise<unknown>;
+    getStakings(addresses: string[], chains?: string[]): Promise<StakingItem[]>;
+    getStakingsByChains(chains: string[]): Promise<StakingItem[]>;
+    getPooledStakings(addresses: string[], chainHashes?: string[]): Promise<StakingItem[]>;
+    subscribeStaking(addresses: string[], chainList?: string[], callback?: (stakingItems: StakingItem[]) => void): Subscription;
+    subscribeChainStakingMetadata(chains: string[], callback: (data: ChainStakingMetadata[]) => void): void;
+    subscribeNominatorMetadata(callback: (data: NominatorMetadata[]) => void): void;
+    getHistories(query?: HistoryQuery): Promise<import("@subwallet/extension-base/services/storage-service/databases").ITransactionHistoryItem[]>;
+    upsertHistory(histories: TransactionHistoryItem[]): Promise<unknown>;
+    addNftCollection(collection: NftCollection): Promise<unknown>;
+    deleteNftCollection(chain: string, collectionId: string): Promise<void>;
+    getAllNftCollection(chainHashes?: string[]): import("dexie").PromiseExtended<NftCollection[]>;
+    subscribeNft(addresses: string[], chainHashes?: string[], callback?: (nfts: INft[]) => void): Subscription;
+    getNft(addresses: string[], chainHashes?: string[]): Promise<INft[]>;
+    addNft(address: string, nft: NftItem): Promise<unknown>;
+    handleNftTransfer(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
+    removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
+    updateChainStore(item: IChain): Promise<unknown>;
+    bulkUpdateChainStore(data: IChain[]): Promise<unknown>;
+    removeFromChainStore(chains: string[]): Promise<number>;
+    getAllChainStore(): Promise<IChain[]>;
+    updateAssetStore(item: _ChainAsset): Promise<unknown>;
+    getAllAssetStore(): Promise<_ChainAsset[]>;
+    removeFromAssetStore(items: string[]): Promise<number>;
+    updateChainStakingMetadata(item: ChainStakingMetadata): Promise<unknown>;
+    getChainStakingMetadata(): Promise<ChainStakingMetadata[]>;
+    getStakingMetadataByChain(chain: string, type?: StakingType): Promise<ChainStakingMetadata | undefined>;
+    updateNominatorMetadata(item: NominatorMetadata): Promise<unknown>;
+    getNominatorMetadata(): Promise<NominatorMetadata[]>;
+}