@subwallet/extension-base 1.1.21-3 → 1.1.23-0

package/koni/background/handlers/State.js

@@ -23,7 +23,7 @@ import RequestService from '@subwallet/extension-base/services/request-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
-import { SUBSCAN_CHAIN_MAP_REVERSE } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import { SUBSCAN_API_CHAIN_MAP, SUBSCAN_BALANCE_CHAIN_MAP_REVERSE } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
@@ -84,14 +84,14 @@ export default class KoniState {
     this.eventService = new EventService();
     this.dbService = new DatabaseService(this.eventService);
     this.keyringService = new KeyringService(this.eventService);
-    this.subscanService = new SubscanService();
     this.notificationService = new NotificationService();
     this.chainService = new ChainService(this.dbService, this.eventService);
+    this.subscanService = new SubscanService(SUBSCAN_API_CHAIN_MAP);
     this.settingService = new SettingService();
     this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService);
     this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new BalanceService(this.chainService);
-    this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService);
+    this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
     this.transactionService = new TransactionService(this.chainService, this.eventService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
     this.walletConnectService = new WalletConnectService(this, this.requestService);
     this.migrationService = new MigrationService(this, this.eventService);
@@ -198,9 +198,13 @@ export default class KoniState {
     });
     return balanceMap;
   }
+  afterChainServiceInit() {
+    this.subscanService.setSubscanChainMap(this.chainService.getSubscanChainMap());
+  }
   async init() {
     await this.eventService.waitCryptoReady;
     await this.chainService.init();
+    this.afterChainServiceInit();
     await this.migrationService.run();
     this.eventService.emit('chain.ready', true);
     this.onReady();
@@ -1469,7 +1473,7 @@ export default class KoniState {
         symbol
       }) => {
         var _currentAssetSettings;
-        const chain = SUBSCAN_CHAIN_MAP_REVERSE[network];
+        const chain = SUBSCAN_BALANCE_CHAIN_MAP_REVERSE[network];
         const chainInfo = chain ? chainMap[chain] : null;
         const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
 
@@ -1478,10 +1482,11 @@ export default class KoniState {
           return;
         }
         const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
-        if (assetMap[tokenKey] && !((_currentAssetSettings = currentAssetSettings[tokenKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+        const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+        if (existedKey && !((_currentAssetSettings = currentAssetSettings[existedKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
           needEnableChains.push(chain);
-          needActiveTokens.push(tokenKey);
-          currentAssetSettings[tokenKey] = {
+          needActiveTokens.push(existedKey);
+          currentAssetSettings[existedKey] = {
             visible: true
           };
         }
@@ -1553,6 +1558,7 @@ export default class KoniState {
     this.chainService.resetWallet(resetAll);
     await this.walletConnectService.resetWallet(resetAll);
     await this.chainService.init();
+    this.afterChainServiceInit();
   }
   async enableMantaPay(updateStore, address, password, seedPhrase) {
     var _this$chainService3, _this$chainService3$m, _this$chainService4, _this$chainService4$m, _this$chainService4$m2, _this$chainService11, _this$chainService11$, _this$chainService11$2;

package/koni/background/subscription.js

@@ -163,7 +163,7 @@ export class KoniSubscription {
   initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
     const subscriptionPromise = subscribeCrowdloan(addresses, substrateApiMap, (networkKey, rs) => {
       this.state.setCrowdloanItem(networkKey, rs);
-    }, this.state.getChainInfoMap());
+    });
     if (onlyRunOnFirstTime) {
       subscriptionPromise.then(unsub => {
         unsub && unsub();

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.21-3",
+  "version": "1.1.23-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -570,6 +570,11 @@
       "require": "./cjs/services/chain-service/handler/AbstractChainHandler.js",
       "default": "./services/chain-service/handler/AbstractChainHandler.js"
     },
+    "./services/chain-service/handler/chain-spec/goldberg": {
+      "types": "./services/chain-service/handler/chain-spec/goldberg.d.ts",
+      "require": "./cjs/services/chain-service/handler/chain-spec/goldberg.js",
+      "default": "./services/chain-service/handler/chain-spec/goldberg.js"
+    },
     "./services/chain-service/handler/EvmApi": {
       "types": "./services/chain-service/handler/EvmApi.d.ts",
       "require": "./cjs/services/chain-service/handler/EvmApi.js",
@@ -668,6 +673,16 @@
       "require": "./cjs/services/history-service/helpers/recoverHistoryStatus.js",
       "default": "./services/history-service/helpers/recoverHistoryStatus.js"
     },
+    "./services/history-service/helpers/subscan-extrinsic-parser-helper": {
+      "types": "./services/history-service/helpers/subscan-extrinsic-parser-helper.d.ts",
+      "require": "./cjs/services/history-service/helpers/subscan-extrinsic-parser-helper.js",
+      "default": "./services/history-service/helpers/subscan-extrinsic-parser-helper.js"
+    },
+    "./services/history-service/subscan-history": {
+      "types": "./services/history-service/subscan-history.d.ts",
+      "require": "./cjs/services/history-service/subscan-history.js",
+      "default": "./services/history-service/subscan-history.js"
+    },
     "./services/history-service/subsquid-multi-chain-history": {
       "types": "./services/history-service/subsquid-multi-chain-history.d.ts",
       "require": "./cjs/services/history-service/subsquid-multi-chain-history.js",
@@ -1307,11 +1322,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.24",
-    "@subwallet/extension-base": "^1.1.21-3",
-    "@subwallet/extension-chains": "^1.1.21-3",
-    "@subwallet/extension-dapp": "^1.1.21-3",
-    "@subwallet/extension-inject": "^1.1.21-3",
+    "@subwallet/chain-list": "0.2.26",
+    "@subwallet/extension-base": "^1.1.23-0",
+    "@subwallet/extension-chains": "^1.1.23-0",
+    "@subwallet/extension-dapp": "^1.1.23-0",
+    "@subwallet/extension-inject": "^1.1.23-0",
     "@subwallet/keyring": "^0.1.1",
     "@subwallet/ui-keyring": "^0.1.1",
     "@walletconnect/sign-client": "^2.8.4",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.1.21-3'
+  version: '1.1.23-0'
 };

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

@@ -6,6 +6,7 @@ export declare const _API_OPTIONS_CHAIN_GROUP: {
     acala: string[];
     turing: string[];
     avail: string[];
+    goldberg: string[];
 };
 export declare const _PREDEFINED_SINGLE_MODES: Record<string, SingleModeJson>;
 export declare const _PURE_EVM_CHAINS: string[];
@@ -16,6 +17,7 @@ export declare const _BALANCE_CHAIN_GROUP: {
     bifrost: string[];
     statemine: string[];
     kusama: string[];
+    centrifuge: string[];
 };
 export declare const _BALANCE_TOKEN_GROUP: {
     crab: string[];
@@ -70,6 +72,7 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     sora_substrate: string[];
     avail: string[];
     pendulum: string[];
+    centrifuge: string[];
 };
 export declare const _BALANCE_PARSING_CHAIN_GROUP: {
     bobabeam: string[];

package/services/chain-service/constants.js

@@ -10,7 +10,8 @@ export const API_MAX_RETRY = 2;
 export const _API_OPTIONS_CHAIN_GROUP = {
   acala: ['acala', 'karura', 'origintrail', 'kintsugi'],
   turing: ['turingStaging', 'turing'],
-  avail: ['kate']
+  avail: ['kate'],
+  goldberg: ['goldberg_testnet']
 };
 export const _PREDEFINED_SINGLE_MODES = {
   subspace: {
@@ -29,9 +30,10 @@ export const _BALANCE_CHAIN_GROUP = {
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude'],
   statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
-  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
+  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
+  // perhaps there are some runtime updates
+  centrifuge: ['centrifuge']
 };
-
 export const _BALANCE_TOKEN_GROUP = {
   crab: ['CKTON', 'PKTON'],
   bitcountry: ['BIT']
@@ -192,8 +194,9 @@ export const _TRANSFER_CHAIN_GROUP = {
   statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
-  avail: ['kate'],
-  pendulum: ['pendulum', 'amplitude', 'amplitude_test']
+  avail: ['kate', 'goldberg_testnet'],
+  pendulum: ['pendulum', 'amplitude', 'amplitude_test'],
+  centrifuge: ['centrifuge']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']

package/services/chain-service/handler/SubstrateApi.js

@@ -16,6 +16,7 @@ import { typesBundle } from '@polkadot/apps-config/api';
 import { TypeRegistry } from '@polkadot/types/create';
 import { formatBalance } from '@polkadot/util';
 import { defaults as addressDefaults } from '@polkadot/util-crypto/address/defaults';
+import goldbergSpec from "./chain-spec/goldberg.js";
 export class SubstrateApi {
   useLightClient = false;
   isApiReady = false;
@@ -85,6 +86,13 @@ export class SubstrateApi {
         types: availSpec.types,
         signedExtensions: availSpec.signedExtensions
       });
+    } else if (_API_OPTIONS_CHAIN_GROUP.goldberg.includes(this.chainSlug)) {
+      api = new ApiPromise({
+        provider,
+        rpc: goldbergSpec.rpc,
+        types: goldbergSpec.types,
+        signedExtensions: goldbergSpec.signedExtensions
+      });
     } else {
       api = new ApiPromise(apiOption);
     }

package/services/chain-service/handler/chain-spec/goldberg.d.ts

@@ -0,0 +1,115 @@
+declare const chainSpec: {
+    types: {
+        AppId: string;
+        DataLookupIndexItem: {
+            appId: string;
+            start: string;
+        };
+        DataLookup: {
+            size: string;
+            index: string;
+        };
+        KateCommitment: {
+            rows: string;
+            cols: string;
+            commitment: string;
+            dataRoot: string;
+        };
+        V1HeaderExtension: {
+            appLookup: string;
+            commitment: string;
+        };
+        HeaderExtension: {
+            _enum: {
+                V1: string;
+            };
+        };
+        DaHeader: {
+            parentHash: string;
+            number: string;
+            stateRoot: string;
+            extrinsicsRoot: string;
+            digest: string;
+            extension: string;
+        };
+        Header: string;
+        CheckAppIdExtra: {
+            appId: string;
+        };
+        CheckAppIdTypes: {};
+        CheckAppId: {
+            extra: string;
+            types: string;
+        };
+        BlockLength: {
+            max: string;
+            cols: string;
+            rows: string;
+            chunkSize: string;
+        };
+        PerDispatchClass: {
+            normal: string;
+            operational: string;
+            mandatory: string;
+        };
+        DataProof: {
+            root: string;
+            proof: string;
+            numberOfLeaves: string;
+            leaf_index: string;
+            leaf: string;
+        };
+        Cell: {
+            row: string;
+            col: string;
+        };
+    };
+    rpc: {
+        kate: {
+            blockLength: {
+                description: string;
+                params: {
+                    name: string;
+                    type: string;
+                    isOptional: boolean;
+                }[];
+                type: string;
+            };
+            queryProof: {
+                description: string;
+                params: ({
+                    name: string;
+                    type: string;
+                    isOptional?: undefined;
+                } | {
+                    name: string;
+                    type: string;
+                    isOptional: boolean;
+                })[];
+                type: string;
+            };
+            queryDataProof: {
+                description: string;
+                params: ({
+                    name: string;
+                    type: string;
+                    isOptional?: undefined;
+                } | {
+                    name: string;
+                    type: string;
+                    isOptional: boolean;
+                })[];
+                type: string;
+            };
+        };
+    };
+    signedExtensions: {
+        CheckAppId: {
+            extrinsic: {
+                appId: string;
+            };
+            payload: {};
+        };
+    };
+};
+export default chainSpec;

package/services/chain-service/handler/chain-spec/goldberg.js

@@ -0,0 +1,116 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const chainSpec = {
+  types: {
+    AppId: 'Compact<u32>',
+    DataLookupIndexItem: {
+      appId: 'AppId',
+      start: 'Compact<u32>'
+    },
+    DataLookup: {
+      size: 'Compact<u32>',
+      index: 'Vec<DataLookupIndexItem>'
+    },
+    KateCommitment: {
+      rows: 'Compact<u16>',
+      cols: 'Compact<u16>',
+      commitment: 'Vec<u8>',
+      dataRoot: 'H256'
+    },
+    V1HeaderExtension: {
+      appLookup: 'DataLookup',
+      commitment: 'KateCommitment'
+    },
+    HeaderExtension: {
+      _enum: {
+        V1: 'V1HeaderExtension'
+      }
+    },
+    DaHeader: {
+      parentHash: 'Hash',
+      number: 'Compact<BlockNumber>',
+      stateRoot: 'Hash',
+      extrinsicsRoot: 'Hash',
+      digest: 'Digest',
+      extension: 'HeaderExtension'
+    },
+    Header: 'DaHeader',
+    CheckAppIdExtra: {
+      appId: 'AppId'
+    },
+    CheckAppIdTypes: {},
+    CheckAppId: {
+      extra: 'CheckAppIdExtra',
+      types: 'CheckAppIdTypes'
+    },
+    BlockLength: {
+      max: 'PerDispatchClass',
+      cols: 'Compact<u32>',
+      rows: 'Compact<u32>',
+      chunkSize: 'Compact<u32>'
+    },
+    PerDispatchClass: {
+      normal: 'u32',
+      operational: 'u32',
+      mandatory: 'u32'
+    },
+    DataProof: {
+      root: 'H256',
+      proof: 'Vec<H256>',
+      numberOfLeaves: 'Compact<u32>',
+      leaf_index: 'Compact<u32>',
+      leaf: 'H256'
+    },
+    Cell: {
+      row: 'u32',
+      col: 'u32'
+    }
+  },
+  rpc: {
+    kate: {
+      blockLength: {
+        description: 'Get Block Length',
+        params: [{
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'BlockLength'
+      },
+      queryProof: {
+        description: 'Generate the kate proof for the given `cells`',
+        params: [{
+          name: 'cells',
+          type: 'Vec<Cell>'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<u8>'
+      },
+      queryDataProof: {
+        description: 'Generate the data proof for the given `index`',
+        params: [{
+          name: 'data_index',
+          type: 'u32'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'DataProof'
+      }
+    }
+  },
+  signedExtensions: {
+    CheckAppId: {
+      extrinsic: {
+        appId: 'AppId'
+      },
+      payload: {}
+    }
+  }
+};
+export default chainSpec;

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

@@ -113,4 +113,5 @@ export declare class ChainService {
     getMetadata(chain: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
     upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
     getMetadataByHash(hash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    getSubscanChainMap(reverse?: boolean): Record<string, string>;
 }

package/services/chain-service/index.js

@@ -1381,4 +1381,22 @@ export class ChainService {
   getMetadataByHash(hash) {
     return this.dbService.stores.metadata.getMetadataByGenesisHash(hash);
   }
+  getSubscanChainMap(reverse) {
+    const result = {};
+    const chainInfoMap = this.getChainInfoMap();
+    Object.values(chainInfoMap).forEach(i => {
+      var _i$extraInfo;
+      if (!((_i$extraInfo = i.extraInfo) !== null && _i$extraInfo !== void 0 && _i$extraInfo.subscanSlug)) {
+        return;
+      }
+      if (!reverse) {
+        var _i$extraInfo2;
+        result[i.slug] = (_i$extraInfo2 = i.extraInfo) === null || _i$extraInfo2 === void 0 ? void 0 : _i$extraInfo2.subscanSlug;
+      } else {
+        var _i$extraInfo3;
+        result[(_i$extraInfo3 = i.extraInfo) === null || _i$extraInfo3 === void 0 ? void 0 : _i$extraInfo3.subscanSlug] = i.slug;
+      }
+    });
+    return result;
+  }
 }

package/services/history-service/helpers/subscan-extrinsic-parser-helper.d.ts

@@ -0,0 +1,6 @@
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicItem } from '@subwallet/extension-base/services/subscan-service/types';
+export declare type ExtrinsicParserFunction = (item: TransactionHistoryItem) => TransactionHistoryItem | null;
+export declare function getExtrinsicParserKey(extrinsicItem: ExtrinsicItem): string;
+export declare const subscanExtrinsicParserMap: Record<string, ExtrinsicParserFunction>;
+export declare const supportedExtrinsicParser: string[];

package/services/history-service/helpers/subscan-extrinsic-parser-helper.js

@@ -0,0 +1,44 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { encodeAddress } from '@polkadot/util-crypto';
+export function getExtrinsicParserKey(extrinsicItem) {
+  return `${extrinsicItem.call_module}.${extrinsicItem.call_module_function}`;
+}
+function paramJsonParse(item) {
+  try {
+    return JSON.parse(item.data || '[]');
+  } catch (e) {
+    return [];
+  }
+}
+function balanceTransferParserFunction(item) {
+  const params = paramJsonParse(item);
+  params.forEach(p => {
+    if (p.name === 'dest') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const toPublicKey = p.value.id || p.value.Id;
+      if (toPublicKey) {
+        item.to = encodeAddress(toPublicKey, 42);
+      }
+    } else if (p.name === 'value') {
+      if (item.amount) {
+        item.amount.value = p.value;
+      }
+    }
+  });
+  item.type = ExtrinsicType.TRANSFER_BALANCE;
+  if (!item.to) {
+    return null;
+  }
+  return item;
+}
+
+// todo: will support other type later
+export const subscanExtrinsicParserMap = {
+  'balances.transfer': balanceTransferParserFunction,
+  'balances.transfer_keep_alive': balanceTransferParserFunction,
+  'balances.transfer_allow_death': balanceTransferParserFunction
+};
+export const supportedExtrinsicParser = Object.keys(subscanExtrinsicParserMap);

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

@@ -1,24 +1,30 @@
 import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
-import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { 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 { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
 import { BehaviorSubject } from 'rxjs';
-export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
+export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface {
     #private;
     private dbService;
     private chainService;
     private eventService;
     private keyringService;
+    private subscanService;
     private historySubject;
-    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService);
+    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService, subscanService: SubscanService);
     private fetchPromise;
-    private interval;
     private recoverInterval;
     private fetchAndLoadHistories;
     getHistories(): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
     getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>>;
+    private fetchSubscanTransactionHistory;
+    subscribeHistories(chain: string, address: string, cb: (items: TransactionHistoryItem[]) => void): {
+        unsubscribe: () => void;
+        value: TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[];
+    };
     updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
@@ -27,8 +33,6 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
     status: ServiceStatus;
     loadData(): Promise<void>;
     persistData(): Promise<void>;
-    startCron(): Promise<void>;
-    stopCron(): Promise<void>;
     startRecoverHistories(): Promise<void>;
     stopRecoverHistories(): Promise<void>;
     recoverHistories(): Promise<void>;