@subwallet/extension-base 1.1.58-0 → 1.1.60-0

package/services/price-service/index.js

@@ -1,27 +1,87 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { CRON_REFRESH_PRICE_INTERVAL } from '@subwallet/extension-base/constants';
+import { CRON_REFRESH_PRICE_INTERVAL, CURRENCY } 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 { getExchangeRateMap, getPriceMap } from '@subwallet/extension-base/services/price-service/coingecko';
+import { SWStorage } from '@subwallet/extension-base/storage';
+import { addLazy } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
-import { BehaviorSubject } from 'rxjs';
+import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
+import { BehaviorSubject, merge } from 'rxjs';
+const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_PRICE_SUBJECT = {
+  currency: DEFAULT_CURRENCY,
   ready: false,
-  currency: 'usd',
+  currencyData: {
+    label: 'United States Dollar',
+    symbol: DEFAULT_CURRENCY,
+    isPrefix: true
+  },
   priceMap: {},
-  price24hMap: {}
+  price24hMap: {},
+  exchangeRateMap: {}
 };
 export class PriceService {
-  priceSubject = new BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
   constructor(dbService, eventService, chainService) {
+    const currency = SWStorage.instance.getItem(CURRENCY);
+    this.currency = new BehaviorSubject(currency || DEFAULT_CURRENCY);
+    this.priceSubject = new BehaviorSubject({
+      ...DEFAULT_PRICE_SUBJECT,
+      currency: this.currency.value
+    });
+    this.rawPriceSubject = new BehaviorSubject({});
+    this.rawExchangeRateMap = new BehaviorSubject({});
     this.status = ServiceStatus.NOT_INITIALIZED;
     this.dbService = dbService;
     this.eventService = eventService;
     this.chainService = chainService;
+    const mergeDataSubject = merge(this.rawPriceSubject, this.rawExchangeRateMap, this.currency);
+    const onUpdate = () => {
+      addLazy('updatePriceData', () => {
+        const priceSubjectValue = JSON.parse(JSON.stringify(this.rawPriceSubject.value));
+        const exchangeRateMapValue = JSON.parse(JSON.stringify(this.rawExchangeRateMap.value));
+        const currencyKey = this.currency.value;
+        if (Object.keys(priceSubjectValue).length === 0) {
+          return;
+        }
+        if (Object.keys(exchangeRateMapValue).length === 0) {
+          return;
+        }
+        if (currencyKey === DEFAULT_CURRENCY) {
+          this.priceSubject.next({
+            ...priceSubjectValue,
+            currency: currencyKey,
+            exchangeRateMap: exchangeRateMapValue,
+            currencyData: staticData[StaticKey.CURRENCY_SYMBOL][currencyKey]
+          });
+        }
+        Object.keys(priceSubjectValue.price24hMap).forEach(key => {
+          priceSubjectValue.price24hMap[key] *= exchangeRateMapValue[currencyKey].exchange;
+          priceSubjectValue.priceMap[key] *= exchangeRateMapValue[currencyKey].exchange;
+        });
+        this.priceSubject.next({
+          ...priceSubjectValue,
+          currency: currencyKey,
+          exchangeRateMap: exchangeRateMapValue,
+          currencyData: staticData[StaticKey.CURRENCY_SYMBOL][currencyKey || DEFAULT_CURRENCY]
+        });
+        this.dbService.updatePriceStore({
+          ...priceSubjectValue,
+          exchangeRateMap: exchangeRateMapValue
+        }).catch(console.error);
+      });
+    };
+    mergeDataSubject.subscribe(onUpdate);
     this.init().catch(console.error);
   }
+  async getTokenPrice(priceIds, currency, resolve, reject) {
+    await Promise.all([getExchangeRateMap(), getPriceMap(priceIds, currency)]).then(([exchangeRateMap, priceMap]) => {
+      this.rawExchangeRateMap.next(exchangeRateMap);
+      this.rawPriceSubject.next(priceMap);
+    });
+  }
   async getPrice() {
     return Promise.resolve(this.priceSubject.value);
   }
@@ -32,18 +92,28 @@ export class PriceService {
     const priceIdList = Object.values(this.chainService.getAssetRegistry()).map(a => a.priceId).filter(a => a);
     return new Set(priceIdList);
   }
-  refreshPriceData(priceIds) {
+  async setPriceCurrency(newCurrencyCode) {
+    if (newCurrencyCode === this.currency.value) {
+      return false;
+    }
+    this.currency.next(newCurrencyCode);
+
+    // Await 1s to get the latest exchange rate
+    await new Promise(resolve => setTimeout(resolve, 300));
+    SWStorage.instance.setItem(CURRENCY, newCurrencyCode);
+    return true;
+  }
+  refreshPriceData(priceIds, resolve, reject) {
     clearTimeout(this.refreshTimeout);
     this.priceIds = priceIds || this.getPriceIds();
 
     // Update for tokens price
-    getTokenPrice(this.priceIds).then(rs => {
-      this.priceSubject.next({
-        ...rs,
-        ready: true
-      });
-      this.dbService.updatePriceStore(rs).catch(console.error);
-    }).catch(console.error);
+    this.getTokenPrice(this.priceIds, this.priceSubject.value.currency).then(() => {
+      resolve && resolve(true);
+    }).catch(e => {
+      console.error(e);
+      reject && reject(false);
+    });
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }
   async init() {
@@ -63,7 +133,7 @@ export class PriceService {
     this.eventService.on('asset.updateState', eventHandler);
   }
   async loadData() {
-    const data = await this.dbService.getPriceStore();
+    const data = await this.dbService.getPriceStore(this.priceSubject.value.currency);
     this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
   }
   async persistData() {

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

@@ -5,6 +5,7 @@ export declare const DEFAULT_AUTO_LOCK_TIME = 15;
 export declare const DEFAULT_UNLOCK_TYPE: WalletUnlockType;
 export declare const DEFAULT_CHAIN_PATROL_ENABLE = false;
 export declare const DEFAULT_LANGUAGE: LanguageType;
+export declare const DEFAULT_CURRENCY = "usd";
 export declare const DEFAULT_SHOW_ZERO_BALANCE = true;
 export declare const DEFAULT_SHOW_BALANCE = false;
 export declare const DEFAULT_ALL_LOGO = "";

package/services/setting-service/constants.js

@@ -9,12 +9,14 @@ export const DEFAULT_AUTO_LOCK_TIME = 15;
 export const DEFAULT_UNLOCK_TYPE = TARGET_ENV === 'extension' ? WalletUnlockType.ALWAYS_REQUIRED : WalletUnlockType.WHEN_NEEDED;
 export const DEFAULT_CHAIN_PATROL_ENABLE = false;
 export const DEFAULT_LANGUAGE = 'en';
+export const DEFAULT_CURRENCY = 'usd';
 export const DEFAULT_SHOW_ZERO_BALANCE = true;
 export const DEFAULT_SHOW_BALANCE = false;
 export const DEFAULT_ALL_LOGO = '';
 export const DEFAULT_CAMERA_ENABLE = false;
 export const DEFAULT_SETTING = {
   language: DEFAULT_LANGUAGE,
+  currency: DEFAULT_CURRENCY,
   browserConfirmationType: DEFAULT_NOTIFICATION_TYPE,
   isShowZeroBalance: DEFAULT_SHOW_ZERO_BALANCE,
   isShowBalance: DEFAULT_SHOW_BALANCE,

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

@@ -42,7 +42,7 @@ export default class DatabaseService {
     private yieldInfoSubscription;
     constructor(eventService: EventService);
     updatePriceStore(priceData: PriceJson): Promise<void>;
-    getPriceStore(): Promise<PriceJson | undefined>;
+    getPriceStore(keyData?: string): Promise<PriceJson | undefined>;
     getStoredBalance(): Promise<IBalance[]>;
     updateBalanceStore(item: BalanceItem): Promise<unknown>;
     updateBulkBalanceStore(items: BalanceItem[]): Promise<unknown>;

package/services/storage-service/DatabaseService.js

@@ -52,10 +52,9 @@ export default class DatabaseService {
   async updatePriceStore(priceData) {
     await this.stores.price.table.put(priceData);
   }
-  async getPriceStore() {
+  async getPriceStore(keyData) {
     try {
-      const rs = await this.stores.price.table.get('usd');
-      return rs;
+      return await this.stores.price.table.get(keyData || 'USD');
     } catch (e) {
       this.logger.error(e);
       return undefined;

package/utils/number.d.ts

@@ -7,6 +7,7 @@ export interface NumberFormatter {
     (input: string, metadata?: Record<string, number>): string;
 }
 export declare const balanceFormatter: NumberFormatter;
+export declare const balanceNoPrefixFormater: NumberFormatter;
 export declare const PREDEFINED_FORMATTER: Record<string, NumberFormatter>;
 export declare const toBNString: (input: string | number | BigNumber, decimal: number) => string;
 export declare const formatNumber: (input: string | number | BigNumber, decimal: number, formatter?: NumberFormatter, metadata?: Record<string, number>) => string;

package/utils/number.js

@@ -90,6 +90,88 @@ export const balanceFormatter = (input, metadata) => {
   }
   return int;
 };
+const intToLocaleString = (str, separator) => str.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+const getNumberSeparators = () => {
+  // default
+  const res = {
+    decimal: '.',
+    thousand: ''
+  };
+
+  // convert a number formatted according to locale
+  const str = parseFloat('1234.56').toLocaleString();
+
+  // if the resulting number does not contain previous number
+  // (i.e. in some Arabic formats), return defaults
+  if (!str.match('1')) {
+    return res;
+  }
+
+  // get decimal and thousand separators
+  res.decimal = str.replace(/.*4(.*)5.*/, '$1');
+  res.thousand = str.replace(/.*1(.*)2.*/, '$1');
+
+  // return results
+  return res;
+};
+export const balanceNoPrefixFormater = (input, metadata) => {
+  const [int, decimal] = input.split('.');
+  const {
+    thousand: thousandSeparator
+  } = getNumberSeparators();
+  const absGteOne = new BigNumber(input).abs().gte(1);
+  const minNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.minNumberFormat) || 2;
+  const maxNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat) || 6;
+  let _decimal = '';
+  if (absGteOne) {
+    // Get only minNumberFormat number at decimal
+    if (decimal.length <= minNumberFormat) {
+      _decimal = decimal;
+    } else {
+      _decimal = decimal.slice(0, minNumberFormat);
+    }
+
+    // Clear zero number for decimal
+    _decimal = clearZero(_decimal);
+  } else {
+    // Index of cursor
+    let index = 0;
+
+    // Count of not zero number in decimal
+    let current = 0;
+
+    // Find a not zero number in decimal
+    let metNotZero = false;
+
+    // Get at least minNumberFormat number not 0 from index 0
+    // If count of 0 number at prefix greater or equal maxNumberFormat should stop and return 0
+
+    // current === minNumberFormat: get enough number
+    // index === decimal.length: end of decimal
+    // index === maxNumberFormat: reach limit of 0 number at prefix
+    if (decimal) {
+      while (current < minNumberFormat && index < decimal.length && (index < maxNumberFormat || metNotZero)) {
+        const _char = decimal[index];
+        _decimal += _char;
+        index++;
+        if (_char !== '0') {
+          metNotZero = true;
+        }
+        if (metNotZero) {
+          current++;
+        }
+      }
+
+      // Clear zero number for decimal
+      _decimal = clearZero(_decimal);
+    }
+  }
+  const int_ = intToLocaleString(int, thousandSeparator);
+  if (_decimal) {
+    return `${int_}.${_decimal}`;
+  }
+  return int_;
+};
 export const PREDEFINED_FORMATTER = {
   balance: balanceFormatter
 };

package/utils/staticData/currencySymbol.json

@@ -0,0 +1,11 @@
+{
+  "USD": {"label": "United States Dollar", "symbol": "USD", "isPrefix": false},
+  "BRL": {"label": "Brazilian Real", "symbol": "BRL", "isPrefix": false},
+  "CNY": {"label": "Chinese Yuan", "symbol": "CNY", "isPrefix": false},
+  "EUR": {"label": "Euro", "symbol": "EUR", "isPrefix": false},
+  "GBP": {"label": "British Pound Sterling", "symbol": "GBP", "isPrefix": false},
+  "HKD": {"label": "Hong Kong Dollar", "symbol": "HKD", "isPrefix": false},
+  "JPY": {"label": "Japanese Yen", "symbol": "JPY", "isPrefix": false},
+  "RUB": {"label": "Russian Ruble", "symbol": "RUB", "isPrefix": false},
+  "VND": {"label": "Vietnamese Dong", "symbol": "VND", "isPrefix": false}
+}

package/utils/staticData/index.d.ts

@@ -3,9 +3,11 @@ export declare const buyTokenConfigs: Record<string, unknown>[];
 export declare const crowdloanFunds: Record<string, unknown>[];
 export declare const marketingCampaigns: Record<string, unknown>;
 export declare const termAndCondition: Record<string, unknown>;
+export declare const currencySymbol: Record<string, unknown>;
 export declare enum StaticKey {
     BUY_SERVICE_INFOS = "buy-service-infos",
     CHAINS = "chains",
+    CURRENCY_SYMBOL = "currency_symbols",
     MARKETING_CAMPAINGS = "marketing-campaigns",
     CROWDLOAN_FUNDS = "crowdloan-funds",
     TERM_AND_CONDITION = "term-and-condition",
@@ -13,6 +15,7 @@ export declare enum StaticKey {
 }
 export declare const staticData: {
     chains: import("@subwallet/chain-list/types")._ChainInfo[];
+    currency_symbols: Record<string, unknown>;
     "buy-service-infos": Record<string, unknown>[];
     "crowdloan-funds": Record<string, unknown>[];
     "marketing-campaigns": Record<string, unknown>;

package/utils/staticData/index.js

@@ -14,10 +14,13 @@ export const crowdloanFunds = require("./crowdloanFunds.json");
 export const marketingCampaigns = require("./marketingCampaigns.json");
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
 export const termAndCondition = require("./termAndCondition.json");
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
+export const currencySymbol = require("./currencySymbol.json");
 export let StaticKey;
 (function (StaticKey) {
   StaticKey["BUY_SERVICE_INFOS"] = "buy-service-infos";
   StaticKey["CHAINS"] = "chains";
+  StaticKey["CURRENCY_SYMBOL"] = "currency_symbols";
   StaticKey["MARKETING_CAMPAINGS"] = "marketing-campaigns";
   StaticKey["CROWDLOAN_FUNDS"] = "crowdloan-funds";
   StaticKey["TERM_AND_CONDITION"] = "term-and-condition";
@@ -25,6 +28,7 @@ export let StaticKey;
 })(StaticKey || (StaticKey = {}));
 export const staticData = {
   [StaticKey.CHAINS]: Object.values(ChainInfoMap),
+  [StaticKey.CURRENCY_SYMBOL]: currencySymbol,
   [StaticKey.BUY_SERVICE_INFOS]: buyServiceInfos,
   [StaticKey.CROWDLOAN_FUNDS]: crowdloanFunds,
   [StaticKey.MARKETING_CAMPAINGS]: marketingCampaigns,