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

package/background/KoniTypes.d.ts

@@ -342,14 +342,16 @@ export interface ExtrinsicDataTypeMap {
     [ExtrinsicType.STAKING_CANCEL_COMPOUNDING]: RequestTuringCancelStakeCompound;
     [ExtrinsicType.STAKING_CANCEL_UNSTAKE]: RequestStakeCancelWithdrawal;
     [ExtrinsicType.STAKING_POOL_WITHDRAW]: any;
-    [ExtrinsicType.EVM_EXECUTE]: any;
+    [ExtrinsicType.EVM_EXECUTE]: TransactionConfig;
     [ExtrinsicType.UNKNOWN]: any;
 }
 export declare enum ExtrinsicStatus {
-    PENDING = "pending",
+    QUEUED = "queued",
+    SUBMITTING = "submitting",
     PROCESSING = "processing",
     SUCCESS = "success",
     FAIL = "fail",
+    CANCELLED = "cancelled",
     UNKNOWN = "unknown"
 }
 export interface TxHistoryItem {
@@ -398,6 +400,7 @@ export interface TransactionHistoryItem<ET extends ExtrinsicType = ExtrinsicType
     toName?: string;
     address: string;
     status: ExtrinsicStatus;
+    transactionId?: string;
     extrinsicHash: string;
     time: number;
     data?: string;
@@ -1357,6 +1360,10 @@ export declare type NotificationParams = Omit<Notification, 'id'>;
 export interface CronReloadRequest {
     data: 'nft' | 'staking';
 }
+export interface AllLogoMap {
+    chainLogoMap: Record<string, string>;
+    assetLogoMap: Record<string, string>;
+}
 export interface KoniRequestSignatures {
     'pri(staking.submitTuringCancelCompound)': [RequestTuringCancelStakeCompound, SWTransactionResponse];
     'pri(staking.submitTuringCompound)': [RequestTuringStakeCompound, SWTransactionResponse];
@@ -1450,6 +1457,7 @@ export interface KoniRequestSignatures {
     'pri(settings.saveTheme)': [ThemeNames, boolean, UiSettings];
     'pri(settings.saveBrowserConfirmationType)': [BrowserConfirmationType, boolean, UiSettings];
     'pri(settings.saveCamera)': [RequestCameraSettings, boolean];
+    'pri(settings.getLogoMaps)': [null, AllLogoMap];
     'pri(transaction.history.getSubscription)': [null, TransactionHistoryItem[], TransactionHistoryItem[]];
     'pri(transfer.checkReferenceCount)': [RequestTransferCheckReferenceCount, boolean];
     'pri(transfer.checkSupporting)': [RequestTransferCheckSupporting, SupportTransferResponse];

package/background/KoniTypes.js

@@ -82,10 +82,12 @@ export let ExtrinsicType;
 })(ExtrinsicType || (ExtrinsicType = {}));
 export let ExtrinsicStatus;
 (function (ExtrinsicStatus) {
-  ExtrinsicStatus["PENDING"] = "pending";
+  ExtrinsicStatus["QUEUED"] = "queued";
+  ExtrinsicStatus["SUBMITTING"] = "submitting";
   ExtrinsicStatus["PROCESSING"] = "processing";
   ExtrinsicStatus["SUCCESS"] = "success";
   ExtrinsicStatus["FAIL"] = "fail";
+  ExtrinsicStatus["CANCELLED"] = "cancelled";
   ExtrinsicStatus["UNKNOWN"] = "unknown";
 })(ExtrinsicStatus || (ExtrinsicStatus = {}));
 export let BasicTxErrorType;

package/cjs/background/KoniTypes.js

@@ -86,10 +86,12 @@ exports.ExtrinsicType = ExtrinsicType;
 let ExtrinsicStatus;
 exports.ExtrinsicStatus = ExtrinsicStatus;
 (function (ExtrinsicStatus) {
-  ExtrinsicStatus["PENDING"] = "pending";
+  ExtrinsicStatus["QUEUED"] = "queued";
+  ExtrinsicStatus["SUBMITTING"] = "submitting";
   ExtrinsicStatus["PROCESSING"] = "processing";
   ExtrinsicStatus["SUCCESS"] = "success";
   ExtrinsicStatus["FAIL"] = "fail";
+  ExtrinsicStatus["CANCELLED"] = "cancelled";
   ExtrinsicStatus["UNKNOWN"] = "unknown";
 })(ExtrinsicStatus || (exports.ExtrinsicStatus = ExtrinsicStatus = {}));
 let BasicTxErrorType;

package/cjs/koni/background/handlers/Extension.js

@@ -2892,6 +2892,13 @@ class KoniExtension {
     }
     return Promise.resolve(false);
   }
+  async getLogoMap() {
+    const [chainLogoMap, assetLogoMap] = await Promise.all([this.#koniState.chainService.getChainLogoMap(), this.#koniState.chainService.getAssetLogoMap()]);
+    return {
+      chainLogoMap,
+      assetLogoMap
+    };
+  }
 
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
@@ -3251,6 +3258,8 @@ class KoniExtension {
         return this.subscribeNotifications(id, port);
       case 'pri(cron.reload)':
         return await this.reloadCron(request);
+      case 'pri(settings.getLogoMaps)':
+        return await this.getLogoMap();
 
       // Default
       default:

package/cjs/koni/background/handlers/State.js

@@ -221,6 +221,8 @@ class KoniState {
   onReady() {
     this.subscription.start();
     this.cron.start();
+    this.historyService.start().catch(console.error);
+    this.priceService.start().catch(console.error);
     this.ready = true;
     this.logger.log('State is ready');
   }
@@ -572,7 +574,8 @@ class KoniState {
           assetType: tokenInfo.type,
           metadata: (0, _utils._parseMetadataForSmartContractAsset)(tokenInfo.contractAddress),
           multiChainAsset: null,
-          hasValue: (0, _utils._isChainTestNet)(this.chainService.getChainInfoByKey(tokenInfo.originChain))
+          hasValue: (0, _utils._isChainTestNet)(this.chainService.getChainInfoByKey(tokenInfo.originChain)),
+          icon: ''
         });
         return isApproved;
       } else {
@@ -1348,11 +1351,15 @@ class KoniState {
     this.cron.stop();
     this.subscription.stop();
     await this.pauseAllNetworks(undefined, 'IDLE mode');
+    await this.historyService.stop();
+    await this.priceService.stop();
   }
   async wakeup() {
     await this.resumeAllNetworks();
     this.cron.start();
     this.subscription.start();
+    await this.historyService.start();
+    await this.priceService.start();
   }
   cancelSubscription(id) {
     if ((0, _subscriptions.isSubscriptionRunning)(id)) {

package/cjs/koni/background/subscription.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -15,6 +16,7 @@ var _handlers = require("@subwallet/extension-base/koni/background/handlers");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/services/event-service/types");
+var _axios = _interopRequireDefault(require("axios"));
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -238,6 +240,17 @@ class KoniSubscription {
     const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
     this.state.updateStakingReward(result, 'fastInterval');
   }
+  async fetchingStakingFromApi() {
+    try {
+      const response = await _axios.default.get('https://staking-data.subwallet.app/api/staking/get');
+      if (response.status === 200) {
+        return response.data;
+      }
+    } catch (e) {
+      this.logger.error(e);
+    }
+    return {};
+  }
   async fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap) {
     const filteredChainInfoMap = {};
     Object.values(chainInfoMap).forEach(chainInfo => {
@@ -249,9 +262,18 @@ class KoniSubscription {
     if (Object.values(filteredChainInfoMap).length === 0) {
       return;
     }
+
+    // Fetch data from helper API
+    const dataFromApi = await this.fetchingStakingFromApi();
     await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
-      const chainStakingMetadata = await (0, _bonding.getChainStakingMetadata)(chainInfo, substrateApiMap[chainInfo.slug]);
-      this.state.updateChainStakingMetadata(chainStakingMetadata);
+      // Use fetch API data if available
+      if (dataFromApi[chainInfo.slug]) {
+        this.state.updateChainStakingMetadata(dataFromApi[chainInfo.slug]);
+      } else {
+        console.warn('Not found staking data from api', chainInfo.slug);
+        const chainStakingMetadata = await (0, _bonding.getChainStakingMetadata)(chainInfo, substrateApiMap[chainInfo.slug]);
+        this.state.updateChainStakingMetadata(chainStakingMetadata);
+      }
     }));
   }
   async fetchNominatorMetadata(currentAddress, chainInfoMap, chainStateMap, substrateApiMap) {

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.0.2-3'
+  version: '1.0.3-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/base/types.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServiceStatus = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+// 'init' | 'started' | 'starting' | 'stopped' | 'stopping'
+let ServiceStatus;
+exports.ServiceStatus = ServiceStatus;
+(function (ServiceStatus) {
+  ServiceStatus["NOT_INITIALIZED"] = "not_initialized";
+  ServiceStatus["INITIALIZING"] = "initializing";
+  ServiceStatus["INITIALIZED"] = "initialized";
+  ServiceStatus["STARTED"] = "started";
+  ServiceStatus["STARTING"] = "starting";
+  ServiceStatus["STOPPED"] = "stopped";
+  ServiceStatus["STOPPING"] = "stopping";
+})(ServiceStatus || (exports.ServiceStatus = ServiceStatus = {}));

package/cjs/services/chain-service/index.js

@@ -157,7 +157,8 @@ class ChainService {
       priceId: '',
       slug: '',
       symbol: '',
-      hasValue: true
+      hasValue: true,
+      icon: ''
     };
     for (const assetInfo of Object.values(this.getAssetRegistry())) {
       if (assetInfo.assetType === _types._AssetType.NATIVE && assetInfo.originChain === chainSlug) {
@@ -558,7 +559,8 @@ class ChainService {
               evmInfo: storedChainInfo.evmInfo,
               substrateInfo: storedChainInfo.substrateInfo,
               isTestnet: storedChainInfo.isTestnet,
-              chainStatus: storedChainInfo.chainStatus
+              chainStatus: storedChainInfo.chainStatus,
+              icon: storedChainInfo.icon
             };
             this.dataMap.chainStateMap[storedSlug] = {
               currentProvider: storedChainInfo.currentProvider,
@@ -730,7 +732,8 @@ class ChainService {
       substrateInfo,
       evmInfo,
       isTestnet: false,
-      chainStatus: _types._ChainStatus.ACTIVE
+      chainStatus: _types._ChainStatus.ACTIVE,
+      icon: '' // Todo: Allow update with custom chain
     };
 
     // insert new chainInfo
@@ -758,7 +761,8 @@ class ChainService {
       priceId: params.chainEditInfo.priceId || null,
       slug: '',
       symbol: params.chainEditInfo.symbol,
-      hasValue: true
+      hasValue: true,
+      icon: ''
     });
 
     // update subscription
@@ -1198,5 +1202,11 @@ class ChainService {
   subscribeAssetSettings() {
     return this.assetSettingSubject;
   }
+  async getChainLogoMap() {
+    return Promise.resolve(_chainList.ChainLogoMap);
+  }
+  async getAssetLogoMap() {
+    return Promise.resolve(_chainList.AssetLogoMap);
+  }
 }
 exports.ChainService = ChainService;

package/cjs/services/history-service/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.HistoryService = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
+var _promise = require("@subwallet/extension-base/utils/promise");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _rxjs = require("rxjs");
 var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
@@ -18,24 +20,10 @@ class HistoryService {
     this.chainService = chainService;
     this.eventService = eventService;
     this.keyringService = keyringService;
-    // Load history from database
-    this.dbService.getHistories().then(histories => {
-      this.historySubject.next(histories);
-    }).catch(console.error);
-
-    // Wait for keyring and chain ready and start
-    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
-      this.getHistories().catch(console.log);
-      this.eventService.on('account.add', () => {
-        this.refreshHistoryInterval();
-      });
-      this.eventService.on('account.remove', address => {
-        this.removeHistoryByAddress(address).catch(console.error);
-      });
-    }).catch(console.error);
+    this.init().catch(console.error);
   }
   fetchPromise = null;
-  nextFetch = undefined;
+  interval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -59,32 +47,16 @@ class HistoryService {
     await this.addHistoryItems(historyRecords);
     return historyRecords;
   }
-  async fetchHistories(addresses) {
-    if (!this.fetchPromise) {
-      // Fetch another histories data data indexer and merge it with stored in database
-      this.fetchPromise = this.fetchAndLoadHistories(addresses);
-    }
-    return this.fetchPromise;
-  }
-  invalidCache() {
-    this.fetchPromise = null;
-  }
-  refreshHistoryInterval() {
-    clearTimeout(this.nextFetch);
-    this.invalidCache();
-    this.getHistories().catch(console.error);
-    this.nextFetch = setTimeout(() => {
-      this.refreshHistoryInterval();
-    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
-  }
   async getHistories() {
     const addressList = _uiKeyring.keyring.getAccounts().map(a => a.address);
-    const currentHistories = this.historySubject.value;
-    if (!this.fetchPromise || currentHistories.length === 0) {
-      await this.fetchHistories(addressList);
-      this.historySubject.next(await this.dbService.getHistories());
+    if (!this.fetchPromise) {
+      this.fetchPromise = (async () => {
+        await this.fetchAndLoadHistories(addressList);
+        const histories = await this.dbService.getHistories();
+        this.historySubject.next(histories);
+      })();
     }
-    return this.historySubject.getValue();
+    return Promise.resolve(this.historySubject.getValue());
   }
   async getHistorySubject() {
     await this.getHistories();
@@ -103,6 +75,10 @@ class HistoryService {
     });
     await this.addHistoryItems(updatedRecords);
   }
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+    await this.dbService.updateHistoryByNewExtrinsicHash(extrinsicHash, updateData);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
 
   // Insert history without check override origin 'app'
   async insertHistories(historyItems) {
@@ -131,5 +107,74 @@ class HistoryService {
     await this.dbService.stores.transaction.removeAllByAddress(address);
     this.historySubject.next(await this.dbService.getHistories());
   }
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  async loadData() {
+    const histories = await this.dbService.getHistories();
+    this.historySubject.next(histories);
+  }
+  async persistData() {
+    await this.dbService.upsertHistory(this.historySubject.value);
+  }
+  async startCron() {
+    await this.getHistories();
+    this.interval = setInterval(() => {
+      this.getHistories().catch(console.error);
+    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  stopCron() {
+    clearTimeout(this.interval);
+    this.fetchPromise = null;
+    return Promise.resolve();
+  }
+  startPromiseHandler = (0, _promise.createPromiseHandler)();
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.loadData();
+    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
+      this.getHistories().catch(console.log);
+      this.eventService.on('account.add', () => {
+        (async () => {
+          await this.stopCron();
+          await this.startCron();
+        })().catch(console.error);
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
+    this.status = _types.ServiceStatus.INITIALIZED;
+  }
+  async start() {
+    try {
+      console.debug('Start history service');
+      this.startPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = _types.ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  stopPromiseHandler = (0, _promise.createPromiseHandler)();
+  async stop() {
+    console.debug('Stop history service');
+    try {
+      this.stopPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STOPPING;
+      await this.persistData();
+      await this.stopCron();
+      this.stopPromiseHandler.resolve();
+      this.status = _types.ServiceStatus.STOPPED;
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }
 exports.HistoryService = HistoryService;

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

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

package/cjs/services/price-service/index.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PriceService = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
 var _coingecko = require("@subwallet/extension-base/services/price-service/coingecko");
+var _promise = require("@subwallet/extension-base/utils/promise");
 var _rxjs = require("rxjs");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -20,34 +22,14 @@ class PriceService {
   priceSubject = new _rxjs.BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
   constructor(dbService, eventService, chainService) {
+    this.status = _types.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;
@@ -71,5 +53,71 @@ class PriceService {
     }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), _constants.CRON_REFRESH_PRICE_INTERVAL);
   }
+  async init() {
+    this.status = _types.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 = _types.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 = (0, _promise.createPromiseHandler)();
+  async start() {
+    console.debug('Start price service');
+    try {
+      this.startPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = _types.ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  async startCron() {
+    this.refreshPriceData();
+    return Promise.resolve();
+  }
+  stopPromiseHandler = (0, _promise.createPromiseHandler)();
+  async stop() {
+    console.debug('Stop price service');
+    try {
+      this.status = _types.ServiceStatus.STOPPING;
+      this.stopPromiseHandler = (0, _promise.createPromiseHandler)();
+      await this.stopCron();
+      await this.persistData();
+      this.status = _types.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;
+  }
 }
 exports.PriceService = PriceService;

package/cjs/services/storage-service/DatabaseService.js

@@ -133,6 +133,16 @@ 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/cjs/services/storage-service/db-stores/Transaction.js

@@ -36,16 +36,12 @@ class TransactionStore extends _BaseStoreWithAddressAndChain.default {
   }
   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;
   }
 }