@subwallet/extension-base 1.0.2-2 → 1.0.3-0

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

@@ -3,17 +3,19 @@ import { EventService } from '@subwallet/extension-base/services/event-service';
 import { SubjectInfo } from '@subwallet/ui-keyring/observable/types';
 import { BehaviorSubject } from 'rxjs';
 export declare class KeyringService {
+    private eventService;
     private readonly currentAccountStore;
     readonly currentAccountSubject: BehaviorSubject<CurrentAccountInfo>;
-    readonly accountsSubject: BehaviorSubject<SubjectInfo>;
+    readonly addressesSubject: BehaviorSubject<SubjectInfo>;
+    readonly accountSubject: BehaviorSubject<SubjectInfo>;
     private beforeAccount;
     readonly keyringStateSubject: BehaviorSubject<KeyringState>;
-    private eventService;
     constructor(eventService: EventService);
     private subscribeAccounts;
     get keyringState(): KeyringState;
     updateKeyringState(isReady?: boolean): void;
     get accounts(): SubjectInfo;
+    get addresses(): SubjectInfo;
     get currentAccount(): CurrentAccountInfo;
     setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
 }

package/services/keyring-service/index.js

@@ -10,8 +10,9 @@ export class KeyringService {
     address: '',
     currentGenesisHash: null
   });
-  accountsSubject = keyring.accounts.subject;
-  beforeAccount = keyring.accounts.subject.value;
+  addressesSubject = keyring.addresses.subject;
+  accountSubject = keyring.accounts.subject;
+  beforeAccount = this.accountSubject.value;
   keyringStateSubject = new BehaviorSubject({
     isReady: false,
     hasMasterPassword: false,
@@ -20,23 +21,17 @@ export class KeyringService {
   constructor(eventService) {
     this.eventService = eventService;
     this.currentAccountStore.get('CurrentAccountInfo', rs => {
-      this.currentAccountSubject.next(rs);
+      rs && this.currentAccountSubject.next(rs);
     });
     this.subscribeAccounts().catch(console.error);
   }
   async subscribeAccounts() {
     // Wait until account ready
-    await new Promise(resolve => {
-      const onReady = () => {
-        this.eventService.off('account.ready', onReady);
-        resolve(true);
-      };
-      this.eventService.on('account.ready', onReady);
-    });
+    await this.eventService.waitAccountReady;
     this.beforeAccount = {
-      ...this.accountsSubject.value
+      ...this.accountSubject.value
     };
-    this.accountsSubject.subscribe(subjectInfo => {
+    this.accountSubject.subscribe(subjectInfo => {
       // Check if accounts changed
       const beforeAddresses = Object.keys(this.beforeAccount);
       const afterAddresses = Object.keys(subjectInfo);
@@ -80,7 +75,10 @@ export class KeyringService {
     });
   }
   get accounts() {
-    return this.accountsSubject.value;
+    return this.accountSubject.value;
+  }
+  get addresses() {
+    return this.addressesSubject.value;
   }
   get currentAccount() {
     return this.currentAccountSubject.value;

package/services/migration-service/scripts/MigrateImportedToken.js

@@ -25,7 +25,8 @@ export default class MigrateImportedToken extends BaseMigrationJob {
                   originChain: item.chain,
                   priceId: null,
                   slug: '',
-                  symbol: item.symbol || ''
+                  symbol: item.symbol || '',
+                  icon: ''
                 });
               } catch (e) {
                 console.log(e);

package/services/price-service/coingecko.js

@@ -16,7 +16,6 @@ export const getTokenPrice = async (priceIds, currency = 'usd') => {
       }
     }
     if (useBackupApi || ((_res = res) === null || _res === void 0 ? void 0 : _res.status) !== 200) {
-      console.log('Use backup api for price');
       useBackupApi = true;
       res = await axios.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
     }

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

@@ -1,9 +1,11 @@
 import { PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject } from 'rxjs';
-export declare class PriceService {
+export declare class PriceService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
+    status: ServiceStatus;
     private dbService;
     private eventService;
     private chainService;
@@ -15,4 +17,23 @@ export declare class PriceService {
     getPriceSubject(): BehaviorSubject<PriceJson>;
     getPriceIds(): Set<string>;
     refreshPriceData(priceIds?: Set<string>): void;
+    init(): Promise<void>;
+    loadData(): Promise<void>;
+    persistData(): Promise<void>;
+    startPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    start(): Promise<void>;
+    startCron(): Promise<void>;
+    stopPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    stop(): Promise<void>;
+    stopCron(): Promise<void>;
+    waitForStarted(): Promise<void>;
+    waitForStopped(): Promise<void>;
 }

package/services/price-service/index.js

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { CRON_REFRESH_PRICE_INTERVAL } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { getTokenPrice } from '@subwallet/extension-base/services/price-service/coingecko';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { BehaviorSubject } from 'rxjs';
 const DEFAULT_PRICE_SUBJECT = {
   ready: false,
@@ -14,34 +16,14 @@ export class PriceService {
   priceSubject = new BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
   constructor(dbService, eventService, chainService) {
+    this.status = ServiceStatus.NOT_INITIALIZED;
     this.dbService = dbService;
     this.eventService = eventService;
     this.chainService = chainService;
-
-    // Fetch data from storage
-    this.getPrice().catch(console.error);
-    const eventHandler = () => {
-      const newPriceIds = this.getPriceIds();
-
-      // Compare two set newPriceIds and this.priceIds
-      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
-        this.priceIds = newPriceIds;
-        this.refreshPriceData(this.priceIds);
-      }
-    };
-    this.eventService.waitAssetReady.then(() => {
-      this.refreshPriceData();
-      this.eventService.on('asset.enable', eventHandler);
-      this.eventService.on('asset.update', eventHandler);
-    }).catch(console.error);
+    this.init().catch(console.error);
   }
   async getPrice() {
-    const isReady = this.priceSubject.value.ready;
-    if (!isReady) {
-      const data = await this.dbService.getPriceStore();
-      this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
-    }
-    return this.priceSubject.value;
+    return Promise.resolve(this.priceSubject.value);
   }
   getPriceSubject() {
     return this.priceSubject;
@@ -62,8 +44,73 @@ export class PriceService {
         ready: true
       });
       this.dbService.updatePriceStore(rs).catch(console.error);
-      console.log('Get Token Price From CoinGecko');
     }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    // Fetch data from storage
+    await this.loadData();
+    const eventHandler = () => {
+      const newPriceIds = this.getPriceIds();
+
+      // Compare two set newPriceIds and this.priceIds
+      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+        this.priceIds = newPriceIds;
+        this.refreshPriceData(this.priceIds);
+      }
+    };
+    await this.eventService.waitAssetReady;
+    this.status = ServiceStatus.INITIALIZED;
+    this.eventService.on('asset.updateState', eventHandler);
+    this.eventService.on('asset.updateState', eventHandler);
+  }
+  async loadData() {
+    const data = await this.dbService.getPriceStore();
+    this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
+  }
+  async persistData() {
+    await this.dbService.updatePriceStore(this.priceSubject.value).catch(console.error);
+  }
+  startPromiseHandler = createPromiseHandler();
+  async start() {
+    console.debug('Start price service');
+    try {
+      this.startPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  async startCron() {
+    this.refreshPriceData();
+    return Promise.resolve();
+  }
+  stopPromiseHandler = createPromiseHandler();
+  async stop() {
+    console.debug('Stop price service');
+    try {
+      this.status = ServiceStatus.STOPPING;
+      this.stopPromiseHandler = createPromiseHandler();
+      await this.stopCron();
+      await this.persistData();
+      this.status = ServiceStatus.STOPPED;
+      this.stopPromiseHandler.resolve();
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  stopCron() {
+    clearTimeout(this.refreshTimeout);
+    return Promise.resolve(undefined);
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }

package/services/request-service/handler/AuthRequestHandler.d.ts

@@ -2,17 +2,19 @@ import { _ChainInfo } from '@subwallet/chain-list/types';
 import { AuthRequestV2 } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AuthorizeRequest, RequestAuthorizeTab } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import { AuthUrls } from '@subwallet/extension-base/services/request-service/types';
 import { BehaviorSubject, Subject } from 'rxjs';
 export default class AuthRequestHandler {
     #private;
+    private keyringService;
     private readonly authorizeStore;
     private authorizeCached;
     private readonly authorizeUrlSubject;
     private readonly evmChainSubject;
     readonly authSubjectV2: BehaviorSubject<AuthorizeRequest[]>;
-    constructor(requestService: RequestService, chainService: ChainService);
+    constructor(requestService: RequestService, chainService: ChainService, keyringService: KeyringService);
     private stripUrl;
     private getAddressList;
     get numAuthRequestsV2(): number;

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

@@ -6,7 +6,6 @@ import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP } from '@subwallet/extension-base/servi
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { getDomainFromUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
-import { accounts } from '@subwallet/ui-keyring/observable/accounts';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { assert } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
@@ -20,7 +19,8 @@ export default class AuthRequestHandler {
   authorizeUrlSubject = new Subject();
   evmChainSubject = new Subject();
   authSubjectV2 = new BehaviorSubject([]);
-  constructor(requestService, chainService) {
+  constructor(requestService, chainService, keyringService) {
+    this.keyringService = keyringService;
     this.#requestService = requestService;
     this.#chainService = chainService;
   }
@@ -30,7 +30,7 @@ export default class AuthRequestHandler {
     return parts[2];
   }
   getAddressList(value = false) {
-    const addressList = Object.keys(accounts.subject.value);
+    const addressList = Object.keys(this.keyringService.accounts);
     return addressList.reduce((addressList, v) => ({
       ...addressList,
       [v]: value
@@ -84,11 +84,11 @@ export default class AuthRequestHandler {
     const chainInfoMaps = this.#chainService.getChainInfoMap();
     const chainStateMap = this.#chainService.getChainStateMap();
     let defaultChain = options.defaultChain;
-    const needEnableChains = [];
+    let needEnableChains = [];
     if (options.url) {
       const domain = getDomainFromUrl(options.url);
       const predefinedSupportChains = PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
-      if (predefinedSupportChains) {
+      if (!defaultChain && predefinedSupportChains) {
         defaultChain = predefinedSupportChains[0];
         options.autoActive && needEnableChains.push(...predefinedSupportChains);
       }
@@ -101,11 +101,17 @@ export default class AuthRequestHandler {
         return (_chainStateMap$chain$ = chainStateMap[chain.slug]) === null || _chainStateMap$chain$ === void 0 ? void 0 : _chainStateMap$chain$.active;
       })) || evmChains[0];
       if (options.autoActive) {
-        if (!needEnableChains.includes(chainInfo.slug)) {
-          needEnableChains.push(chainInfo.slug);
+        var _chainInfo;
+        if (!needEnableChains.includes((_chainInfo = chainInfo) === null || _chainInfo === void 0 ? void 0 : _chainInfo.slug)) {
+          var _chainInfo2;
+          needEnableChains.push((_chainInfo2 = chainInfo) === null || _chainInfo2 === void 0 ? void 0 : _chainInfo2.slug);
         }
       }
     }
+    needEnableChains = needEnableChains.filter(slug => {
+      var _chainStateMap$slug;
+      return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
+    });
     needEnableChains.length > 0 && this.#chainService.enableChains(needEnableChains);
     return chainInfo;
   }

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

@@ -67,16 +67,7 @@ export default class EvmRequestHandler {
     });
     this.confirmationsQueueSubject.next(confirmations);
     if (!isInternal) {
-      // Not open new popup and use existed
-      const popupList = this.#requestService.popup;
-      if (this.#requestService.popup.length > 0) {
-        // eslint-disable-next-line no-void
-        void chrome.windows.update(popupList[0], {
-          focused: true
-        });
-      } else {
-        this.#requestService.popupOpen();
-      }
+      this.#requestService.popupOpen();
     }
     this.#requestService.updateIconV2();
     return promise;
@@ -127,7 +118,8 @@ export default class EvmRequestHandler {
       data: toBuffer(config.data)
     };
     const common = Common.custom({
-      chainId: config.chainId
+      chainId: config.chainId,
+      defaultHardfork: 'petersburg'
     });
 
     // @ts-ignore
@@ -140,11 +132,15 @@ export default class EvmRequestHandler {
     const {
       estimateGas,
       from,
-      gasPrice
+      gas,
+      gasPrice,
+      value
     } = transaction;
     const pair = keyring.getPair(from);
     const params = {
       ...transaction,
+      gas: anyNumberToBN(gas).toNumber(),
+      value: anyNumberToBN(value).toNumber(),
       gasPrice: anyNumberToBN(gasPrice).toNumber(),
       gasLimit: anyNumberToBN(estimateGas).toNumber()
       // nonce: await web3.eth.getTransactionCount(from) // Todo: fill this value from transaction service

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

@@ -1,6 +1,7 @@
 import { AuthRequestV2, ConfirmationDefinitions, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationType, RequestConfirmationComplete } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-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';
@@ -8,8 +9,9 @@ import { BehaviorSubject, Subject } from 'rxjs';
 import { SignerPayloadJSON } from '@polkadot/types/types/extrinsic';
 export default class RequestService {
     #private;
+    private keyringService;
     readonly settingService: SettingService;
-    constructor(chainService: ChainService, settingService: SettingService);
+    constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;
     getAddressList(value?: boolean): Record<string, boolean>;

package/services/request-service/index.js

@@ -6,7 +6,6 @@ import EvmRequestHandler from '@subwallet/extension-base/services/request-servic
 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;
@@ -17,12 +16,13 @@ export default class RequestService {
   #evmRequestHandler;
 
   // Common
-  constructor(chainService, settingService) {
+  constructor(chainService, settingService, keyringService) {
+    this.keyringService = keyringService;
     this.#chainService = chainService;
     this.settingService = settingService;
     this.#popupHandler = new PopupHandler(this);
     this.#metadataRequestHandler = new MetadataRequestHandler(this);
-    this.#authRequestHandler = new AuthRequestHandler(this, this.#chainService);
+    this.#authRequestHandler = new AuthRequestHandler(this, this.#chainService, this.keyringService);
     this.#substrateRequestHandler = new SubstrateRequestHandler(this);
     this.#evmRequestHandler = new EvmRequestHandler(this);
 
@@ -36,7 +36,7 @@ export default class RequestService {
     this.#popupHandler.updateIconV2(shouldClose);
   }
   getAddressList(value = false) {
-    const addressList = Object.keys(accounts.subject.value);
+    const addressList = Object.keys(this.keyringService.accounts);
     return addressList.reduce((addressList, v) => ({
       ...addressList,
       [v]: value
@@ -51,7 +51,16 @@ export default class RequestService {
     this.#popupHandler.popupClose();
   }
   popupOpen() {
-    this.#popupHandler.popupOpen();
+    // Not open new popup and use existed
+    const popupList = this.#popupHandler.popup;
+    if (popupList && popupList.length > 0) {
+      var _chrome$windows$updat;
+      (_chrome$windows$updat = chrome.windows.update(popupList[0], {
+        focused: true
+      })) === null || _chrome$windows$updat === void 0 ? void 0 : _chrome$windows$updat.catch(console.error);
+    } else {
+      this.#popupHandler.popupOpen();
+    }
   }
 
   // Metadata

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

@@ -41,10 +41,12 @@ export default class DatabaseService {
     subscribeNominatorMetadata(callback: (data: NominatorMetadata[]) => void): void;
     getHistories(query?: HistoryQuery): Promise<import("@subwallet/extension-base/services/storage-service/databases").ITransactionHistoryItem[]>;
     upsertHistory(histories: TransactionHistoryItem[]): Promise<unknown>;
+    updateHistoryByNewExtrinsicHash(extrinsicHash: string, updateData: Partial<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;
+    cleanUpNft(chain: string, owner: string, collectionIds: string[], nftIds: string[], ownNothing?: boolean): Promise<number>;
     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>;