@subwallet/extension-base 1.1.65-0 → 1.1.67-0

package/services/earning-service/service.js

@@ -190,7 +190,7 @@ export default class EarningService {
     this.status = ServiceStatus.STARTING;
 
     // Start subscribe pools' info
-    await this.runSubscribePoolsInfo();
+    // await this.runSubscribePoolsInfo();
 
     // Start subscribe pools' position
     await this.runSubscribePoolsPosition();
@@ -217,7 +217,7 @@ export default class EarningService {
     await this.persistData();
 
     // Stop subscribe pools' info
-    this.runUnsubscribePoolsInfo();
+    // this.runUnsubscribePoolsInfo();
 
     // Stop subscribe pools' position
     this.runUnsubscribePoolsPosition();

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

@@ -14,9 +14,12 @@ export declare class PriceService implements StoppableServiceInterface, PersistD
     private rawExchangeRateMap;
     private refreshTimeout;
     private priceIds;
-    private currency;
+    private readonly currency;
     constructor(dbService: DatabaseService, eventService: EventService, chainService: ChainService);
     private getTokenPrice;
+    private getCurrentCurrencySubject;
+    private setCurrentCurrency;
+    private getCurrentCurrency;
     private refreshPromise;
     private refreshPriceMapByAction;
     private calculatePriceMap;

package/services/price-service/index.js

@@ -5,6 +5,7 @@ import { CRON_REFRESH_PRICE_INTERVAL, CURRENCY } from '@subwallet/extension-base
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { getExchangeRateMap, getPriceMap } from '@subwallet/extension-base/services/price-service/coingecko';
 import { SWStorage } from '@subwallet/extension-base/storage';
+import { CurrentCurrencyStore } from '@subwallet/extension-base/stores';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
 import { BehaviorSubject } from 'rxjs';
@@ -23,12 +24,10 @@ const DEFAULT_PRICE_SUBJECT = {
 };
 export class PriceService {
   priceIds = new Set();
+  currency = new CurrentCurrencyStore();
   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
+      ...DEFAULT_PRICE_SUBJECT
     });
     this.rawPriceSubject = new BehaviorSubject({});
     this.rawExchangeRateMap = new BehaviorSubject({});
@@ -36,7 +35,11 @@ export class PriceService {
     this.dbService = dbService;
     this.eventService = eventService;
     this.chainService = chainService;
-    this.init().catch(console.error);
+    const updateCurrency = currentCurrency => {
+      const currency = SWStorage.instance.getItem(CURRENCY);
+      this.setCurrentCurrency(currency || currentCurrency || DEFAULT_CURRENCY);
+    };
+    this.init().then(() => this.getCurrentCurrency(updateCurrency)).catch(console.error);
   }
   async getTokenPrice(priceIds, currency, resolve, reject) {
     await Promise.all([getExchangeRateMap(), getPriceMap(priceIds, currency)]).then(([exchangeRateMap, priceMap]) => {
@@ -44,12 +47,29 @@ export class PriceService {
       this.rawPriceSubject.next(priceMap);
     });
   }
+  getCurrentCurrencySubject() {
+    return this.currency.getSubject();
+  }
+  setCurrentCurrency(currency) {
+    this.currency.set('Currency', currency);
+  }
+  getCurrentCurrency(update) {
+    this.currency.get('Currency', value => {
+      update(value || DEFAULT_CURRENCY);
+    });
+  }
   refreshPromise = null;
   refreshPriceMapByAction() {
     this.refreshPromise = (async () => {
       try {
         await this.refreshPromise;
-        const newPriceMap = await this.calculatePriceMap();
+        const {
+          promise,
+          resolve
+        } = createPromiseHandler();
+        this.getCurrentCurrency(resolve);
+        const currencyKey = await promise;
+        const newPriceMap = await this.calculatePriceMap(currencyKey || DEFAULT_CURRENCY);
         if (newPriceMap) {
           this.priceSubject.next(newPriceMap);
         }
@@ -60,16 +80,13 @@ export class PriceService {
       }
     })();
   }
-  async calculatePriceMap() {
+  async calculatePriceMap(currency) {
     const {
       price24hMap,
       priceMap
     } = this.rawPriceSubject.value;
     const exchangeRateData = this.rawExchangeRateMap.value;
-    const currencyKey = this.currency.value;
-    if (Object.keys(this.rawPriceSubject.value).length === 0) {
-      return;
-    }
+    const currencyKey = currency || DEFAULT_CURRENCY;
     if (Object.keys(exchangeRateData).length === 0) {
       return;
     }
@@ -105,10 +122,7 @@ export class PriceService {
     return new Set(priceIdList);
   }
   async setPriceCurrency(newCurrencyCode) {
-    if (newCurrencyCode === this.currency.value) {
-      return false;
-    }
-    this.currency.next(newCurrencyCode);
+    this.setCurrentCurrency(newCurrencyCode);
 
     // Await 1s to get the latest exchange rate
     await new Promise(resolve => setTimeout(resolve, 300));
@@ -140,9 +154,9 @@ export class PriceService {
         this.refreshPriceMapByAction();
       }
     };
-    this.currency.subscribe(currency => {
+    this.getCurrentCurrencySubject().subscribe(currency => {
       console.log('Currency changed', currency);
-      this.calculatePriceMap().then(data => {
+      this.calculatePriceMap(currency).then(data => {
         if (data) {
           this.priceSubject.next(data);
         }

package/stores/CurrentCurrencyStore.d.ts

@@ -0,0 +1,5 @@
+import { CurrencyType } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class CurrentCurrencyStore extends SubscribableStore<CurrencyType> {
+    constructor();
+}

package/stores/CurrentCurrencyStore.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class CurrentCurrencyStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}current_currency` : null);
+  }
+}

package/stores/index.d.ts

@@ -1,3 +1,4 @@
 export { default as AccountsStore } from './Accounts';
 export { default as MetadataStore } from './Metadata';
 export { default as CurrentAccountStore } from './CurrentAccountStore';
+export { default as CurrentCurrencyStore } from './CurrentCurrencyStore';

package/stores/index.js

@@ -3,4 +3,5 @@
 
 export { default as AccountsStore } from "./Accounts.js";
 export { default as MetadataStore } from "./Metadata.js";
-export { default as CurrentAccountStore } from "./CurrentAccountStore.js";
+export { default as CurrentAccountStore } from "./CurrentAccountStore.js";
+export { default as CurrentCurrencyStore } from "./CurrentCurrencyStore.js";

package/utils/gear/grc20.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { GearApi } from '@gear-js/api';
+import { TransactionBuilder } from 'sails-js';
+import { ApiPromise } from '@polkadot/api';
+export declare type ActorId = `0x${string}`;
+export declare type U256 = bigint;
+export declare const DEFAULT_GEAR_ADDRESS: {
+    ALICE: string;
+    BOB: string;
+};
+export declare class GRC20 {
+    api: GearApi;
+    programId: `0x${string}`;
+    private registry;
+    constructor(api: GearApi, programId?: `0x${string}`);
+    newCtorFromCode(code: Uint8Array | Buffer, name: string, symbol: string, decimals: number | string): TransactionBuilder<null>;
+    newCtorFromCodeId(codeId: `0x${string}`, name: string, symbol: string, decimals: number | string): TransactionBuilder<null>;
+    approve(spender: ActorId, value: U256): TransactionBuilder<boolean>;
+    fromTransfer(from: ActorId, to: ActorId, value: U256): TransactionBuilder<boolean>;
+    setBalance(newBalance: U256): TransactionBuilder<boolean>;
+    transfer(to: ActorId, value: U256): TransactionBuilder<boolean>;
+    allowance(owner: ActorId, spender: ActorId, originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<U256>;
+    balanceOf(owner: ActorId, originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<U256>;
+    decimals(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<number | string>;
+    name(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<string>;
+    symbol(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<string>;
+    totalSupply(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<U256>;
+}
+export declare function getGRC20ContractPromise(apiPromise: ApiPromise, contractAddress: string): GRC20;

package/utils/gear/grc20.js

@@ -0,0 +1,131 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// https://github.com/breathx/gear-erc20/blob/master/js/src/lib.ts
+
+import { decodeAddress } from '@gear-js/api';
+import { TransactionBuilder } from 'sails-js';
+import { TypeRegistry } from '@polkadot/types';
+export const DEFAULT_GEAR_ADDRESS = {
+  ALICE: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+  BOB: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty'
+};
+export class GRC20 {
+  constructor(api, programId = '0x') {
+    this.api = api;
+    this.programId = programId;
+    const types = {
+      ActorId: '([u8; 32])',
+      U256: '([u64; 4])'
+    };
+    this.registry = new TypeRegistry();
+    this.registry.setKnownTypes({
+      types
+    });
+    this.registry.register(types);
+  }
+  newCtorFromCode(code, name, symbol, decimals) {
+    const builder = new TransactionBuilder(this.api, this.registry, 'upload_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', code);
+    this.programId = builder.programId;
+    return builder;
+  }
+  newCtorFromCodeId(codeId, name, symbol, decimals) {
+    const builder = new TransactionBuilder(this.api, this.registry, 'create_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', codeId);
+    this.programId = builder.programId;
+    return builder;
+  }
+  approve(spender, value) {
+    return new TransactionBuilder(this.api, this.registry, 'send_message', ['Approve', spender, value], '(String, ActorId, U256)', 'bool', this.programId);
+  }
+  fromTransfer(from, to, value) {
+    return new TransactionBuilder(this.api, this.registry, 'send_message', ['FromTransfer', from, to, value], '(String, ActorId, ActorId, U256)', 'bool', this.programId);
+  }
+  setBalance(newBalance) {
+    return new TransactionBuilder(this.api, this.registry, 'send_message', ['SetBalance', newBalance], '(String, U256)', 'bool', this.programId);
+  }
+  transfer(to, value) {
+    return new TransactionBuilder(this.api, this.registry, 'send_message', ['Transfer', to, value], '(String, ActorId, U256)', 'bool', this.programId);
+  }
+  async allowance(owner, spender, originAddress, value, atBlock) {
+    const payload = this.registry.createType('(String, ActorId, ActorId)', ['Allowance', owner, spender]).toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, U256)', reply.payload);
+    return result[1].toBigInt();
+  }
+  async balanceOf(owner, originAddress, value, atBlock) {
+    const payload = this.registry.createType('(String, ActorId)', ['BalanceOf', owner]).toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, U256)', reply.payload);
+    return result[1].toBigInt();
+  }
+  async decimals(originAddress, value, atBlock) {
+    const payload = this.registry.createType('String', 'Decimals').toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, u8)', reply.payload);
+    return result[1].toNumber();
+  }
+  async name(originAddress, value, atBlock) {
+    const payload = this.registry.createType('String', 'Name').toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, String)', reply.payload);
+    return result[1].toString();
+  }
+  async symbol(originAddress, value, atBlock) {
+    const payload = this.registry.createType('String', 'Symbol').toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, String)', reply.payload);
+    return result[1].toString();
+  }
+  async totalSupply(originAddress, value, atBlock) {
+    const payload = this.registry.createType('String', 'TotalSupply').toU8a();
+    const reply = await this.api.message.calculateReply({
+      destination: this.programId,
+      origin: decodeAddress(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this.registry.createType('(String, U256)', reply.payload);
+    return result[1].toBigInt();
+  }
+}
+export function getGRC20ContractPromise(apiPromise, contractAddress) {
+  const gearApi = apiPromise;
+  return new GRC20(gearApi, contractAddress);
+}

package/utils/gear/index.d.ts

@@ -0,0 +1 @@
+export * from './grc20';

package/utils/gear/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./grc20.js";

package/utils/index.d.ts

@@ -45,12 +45,13 @@ export * from './array';
 export * from './asset';
 export * from './environment';
 export * from './eth';
-export * from './number';
+export * from './fetchEvmChainInfo';
+export * from './fetchStaticData';
+export * from './gear';
 export * from './lazy';
+export * from './number';
+export * from './object';
 export * from './promise';
 export * from './registry';
-export * from './translate';
-export * from './object';
-export * from './fetchStaticData';
-export * from './fetchEvmChainInfo';
 export * from './swap';
+export * from './translate';

package/utils/index.js

@@ -347,12 +347,13 @@ export * from "./array.js";
 export * from "./asset.js";
 export * from "./environment.js";
 export * from "./eth.js";
-export * from "./number.js";
+export * from "./fetchEvmChainInfo.js";
+export * from "./fetchStaticData.js";
+export * from "./gear/index.js";
 export * from "./lazy.js";
+export * from "./number.js";
+export * from "./object.js";
 export * from "./promise.js";
 export * from "./registry.js";
-export * from "./translate.js";
-export * from "./object.js";
-export * from "./fetchStaticData.js";
-export * from "./fetchEvmChainInfo.js";
-export * from "./swap.js";
+export * from "./swap.js";
+export * from "./translate.js";