@subwallet/extension-base 1.0.2-3 → 1.0.4-0

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.updateState', eventHandler);
-      this.eventService.on('asset.updateState', 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;
@@ -65,4 +47,70 @@ export class PriceService {
     }).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/storage-service/DatabaseService.d.ts

@@ -41,6 +41,7 @@ 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[]>;

package/services/storage-service/DatabaseService.js

@@ -126,6 +126,16 @@ export default class DatabaseService {
     const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
     return this.stores.transaction.bulkUpsert(cleanedHistory);
   }
+  async updateHistoryByNewExtrinsicHash(extrinsicHash, updateData) {
+    // this.logger.log('Updating transaction histories');
+    const canUpdate = updateData && extrinsicHash;
+    if (!canUpdate) {
+      return;
+    }
+    return this.stores.transaction.updateWithQuery({
+      extrinsicHash
+    }, updateData);
+  }
 
   // NFT Collection
   async addNftCollection(collection) {

package/services/storage-service/db-stores/Transaction.d.ts

@@ -4,9 +4,11 @@ export interface HistoryQuery {
     chain?: string;
     address?: string;
     extrinsicHash?: string;
+    transactionId?: string;
 }
 export default class TransactionStore extends BaseStoreWithAddressAndChain<ITransactionHistoryItem> {
     getHistoryByAddressAsObject(address: string): Promise<ITransactionHistoryItem[]>;
     queryHistory(query?: HistoryQuery): Promise<ITransactionHistoryItem[]>;
     bulkUpsert(records: ITransactionHistoryItem[]): Promise<unknown>;
+    updateWithQuery(query: HistoryQuery, update: Partial<ITransactionHistoryItem>): Promise<unknown>;
 }

package/services/storage-service/db-stores/Transaction.js

@@ -29,16 +29,12 @@ export default class TransactionStore extends BaseStoreWithAddressAndChain {
   }
   async bulkUpsert(records) {
     await this.table.bulkPut(records);
-
-    // await Promise.all(records.map((record) => {
-    //   return this.table.where({
-    //     chain: record.chain,
-    //     address: record.address,
-    //     extrinsicHash: record.extrinsicHash
-    //   }).filter((item) => (item.origin === 'app' && record.origin !== 'app'))
-    //     .delete();
-    // }));
-
+    return true;
+  }
+  async updateWithQuery(query, update) {
+    await this.table.where(query).modify(record => {
+      return Object.assign(record, update);
+    });
     return true;
   }
 }

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

@@ -36,6 +36,8 @@ export default class TransactionService {
     private updateTransaction;
     private getTransactionLink;
     private transactionToHistories;
+    private onSigned;
+    private onSend;
     private onHasTransactionHash;
     private handlePostProcessing;
     private onSuccess;

package/services/transaction-service/index.js

@@ -37,7 +37,7 @@ export default class TransactionService {
     return Object.values(this.transactions);
   }
   get processingTransactions() {
-    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.PENDING || t.status === ExtrinsicStatus.PROCESSING);
+    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.QUEUED || t.status === ExtrinsicStatus.PROCESSING);
   }
   getTransaction(id) {
     return this.transactions[id];
@@ -157,6 +157,7 @@ export default class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal);
     return {
       ...transaction,
       createdAt: new Date(),
@@ -164,10 +165,10 @@ export default class TransactionService {
       errors: transaction.errors || [],
       warnings: transaction.warnings || [],
       url: transaction.url || EXTENSION_REQUEST_URL,
-      status: ExtrinsicStatus.PENDING,
+      status: ExtrinsicStatus.QUEUED,
       isInternal,
-      id: getTransactionId(transaction.chainType, transaction.chain, isInternal),
-      extrinsicHash: ''
+      id: transactionId,
+      extrinsicHash: transactionId
     };
   }
   async addTransaction(inputTransaction) {
@@ -180,8 +181,6 @@ export default class TransactionService {
     this.transactionSubject.next({
       ...transactions
     });
-
-    // Send transaction
     return await this.sendTransaction(transaction);
   }
   generateBeforeHandleResponseErrors(errors) {
@@ -208,7 +207,8 @@ export default class TransactionService {
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
     await new Promise(resolve => {
-      emitter.on('extrinsicHash', data => {
+      emitter.on('signed', data => {
+        validatedTransaction.id = data.id;
         validatedTransaction.extrinsicHash = data.extrinsicHash;
         resolve();
       });
@@ -224,6 +224,12 @@ export default class TransactionService {
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    emitter.on('signed', data => {
+      this.onSigned(data);
+    });
+    emitter.on('send', data => {
+      this.onSend(data);
+    });
     emitter.on('extrinsicHash', data => {
       this.onHasTransactionHash(data);
     });
@@ -276,7 +282,8 @@ export default class TransactionService {
       to: '',
       chainType: transaction.chainType,
       address: transaction.address,
-      status: ExtrinsicStatus.PROCESSING,
+      status: transaction.status,
+      transactionId: transaction.id,
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt.getTime(),
       fee: transaction.estimateFee,
@@ -419,8 +426,14 @@ export default class TransactionService {
           break;
         }
       case ExtrinsicType.EVM_EXECUTE:
-        // Todo: Update historyItem.to
-        break;
+        {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const data = parseTransactionData(transaction.data);
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          historyItem.to = (data === null || data === void 0 ? void 0 : data.to) || '';
+          break;
+        }
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -439,17 +452,36 @@ export default class TransactionService {
     }
     return [historyItem];
   }
+  onSigned({
+    id
+  }) {
+    console.log(`Transaction "${id}" is signed`);
+  }
+  onSend({
+    id
+  }) {
+    // Update transaction status
+    this.updateTransaction(id, {
+      status: ExtrinsicStatus.SUBMITTING
+    });
+
+    // Create Input History Transaction History
+    this.historyService.insertHistories(this.transactionToHistories(id)).catch(console.error);
+    console.log(`Transaction "${id}" is sent`);
+  }
   onHasTransactionHash({
-    eventLogs,
     extrinsicHash,
     id
   }) {
     // Write processing transaction history
-    this.updateTransaction(id, {
+    const updateData = {
       extrinsicHash,
       status: ExtrinsicStatus.PROCESSING
-    });
-    this.historyService.insertHistories(this.transactionToHistories(id, eventLogs)).catch(console.error);
+    };
+    this.updateTransaction(id, updateData);
+
+    // In this case transaction id is the same as extrinsic hash and will change after below update
+    this.historyService.updateHistoryByExtrinsicHash(id, updateData).catch(console.error);
     console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
   }
   handlePostProcessing(id) {
@@ -513,16 +545,17 @@ export default class TransactionService {
     id
   }) {
     const transaction = this.getTransaction(id);
+    const nextStatus = ExtrinsicStatus.FAIL;
     if (transaction) {
       this.updateTransaction(id, {
-        status: ExtrinsicStatus.FAIL,
+        status: nextStatus,
         errors
       });
       console.log('Transaction failed', id, transaction.extrinsicHash);
 
       // Write failed transaction history
       this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
-        status: ExtrinsicStatus.FAIL,
+        status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
@@ -642,6 +675,12 @@ export default class TransactionService {
           }
           signedTransaction = signed;
         }
+
+        // Emit signed event
+        emitter.emit('signed', eventData);
+
+        // Send transaction
+        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
         signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
           eventData.extrinsicHash = hash;
           emitter.emit('extrinsicHash', eventData);
@@ -680,7 +719,6 @@ export default class TransactionService {
       errors: [],
       warnings: []
     };
-    console.debug(address, transaction);
     transaction.signAsync(address, {
       signer: {
         signPayload: async payload => {
@@ -692,6 +730,11 @@ export default class TransactionService {
         }
       }
     }).then(rs => {
+      // Emit signed event
+      emitter.emit('signed', eventData);
+
+      // Send transaction
+      emitter.emit('send', eventData); // This event is needed after sending transaction with queue
       rs.send(txState => {
         // handle events, logs, history
         if (!txState || !txState.status) {

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

@@ -41,6 +41,8 @@ export interface TransactionEventResponse extends ValidateTransactionResponse {
     eventLogs?: EventRecord[];
 }
 export interface TransactionEventMap {
+    send: (response: TransactionEventResponse) => void;
+    signed: (response: TransactionEventResponse) => void;
     extrinsicHash: (response: TransactionEventResponse) => void;
     error: (response: TransactionEventResponse) => void;
     success: (response: TransactionEventResponse) => void;

package/services/transaction-service/utils.js

@@ -9,15 +9,17 @@ export function parseTransactionData(data) {
   return data;
 }
 export function getTransactionLink(chainInfo, extrinsicHash) {
-  const explorerLink = _getBlockExplorerFromChain(chainInfo);
-  if (_isPureEvmChain(chainInfo)) {
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
-    }
-  } else {
+  if (extrinsicHash.startsWith('0x')) {
     const explorerLink = _getBlockExplorerFromChain(chainInfo);
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+    if (_isPureEvmChain(chainInfo)) {
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
+      }
+    } else {
+      const explorerLink = _getBlockExplorerFromChain(chainInfo);
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+      }
     }
   }
   return undefined;

package/utils/promise.d.ts

@@ -0,0 +1,6 @@
+export declare function createPromiseHandler<T>(): {
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+    promise: Promise<T>;
+};
+export declare type PromiseHandler<T> = ReturnType<typeof createPromiseHandler<T>>;

package/utils/promise.js

@@ -0,0 +1,20 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export function createPromiseHandler() {
+  let _resolve = () => {
+    console.warn('This promise handler is not implemented');
+  };
+  let _reject = () => {
+    console.warn('This promise handler is not implemented');
+  };
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise
+  };
+}