@subwallet/extension-base 1.0.13-0 → 1.1.1

package/services/chain-service/handler/manta/MantaPrivateHandler.js

@@ -0,0 +1,140 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BaseWallet, MantaPayWallet } from 'manta-extension-sdk';
+import { Subject } from 'rxjs';
+export class MantaPrivateHandler {
+  _privateWallet = undefined;
+  syncStateSubject = new Subject();
+  constructor(dbService) {
+    this.dbService = dbService;
+    this.syncState = {
+      isSyncing: false,
+      progress: 0
+    };
+    this.syncStateSubject.next(this.syncState);
+  }
+  setCurrentAddress(address) {
+    this.currentAddress = address;
+  }
+  getSyncState() {
+    return this.syncState;
+  }
+  get privateWallet() {
+    return this._privateWallet;
+  }
+  subscribeSyncState() {
+    return this.syncStateSubject;
+  }
+  async updateMantaPayConfig(address, chain, changes) {
+    await this.dbService.updateMantaPayData(`config_${chain}_${address}`, changes);
+  }
+  async saveMantaPayConfig(config) {
+    await this.dbService.setMantaPayData({
+      key: `config_${config.chain}_${config.address}`,
+      ...config
+    });
+  }
+  async getMantaPayConfig(address, chain) {
+    return this.dbService.getMantaPayData(`config_${chain}_${address}`);
+  }
+  async getMantaPayFirstConfig(chain) {
+    return this.dbService.getMantaPayFirstConfig(chain);
+  }
+  async deleteMantaPayConfig(address, chain) {
+    return this.dbService.deleteMantaPayConfig(`config_${chain}_${address}`);
+  }
+  async saveMantaAuthContext(context) {
+    await this.dbService.setMantaPayData({
+      key: `authContext_${context.chain}_${context.address}`,
+      ...context
+    });
+  }
+  async getMantaAuthContext(address, chain) {
+    return this.dbService.getMantaPayData(`authContext_${chain}_${address}`);
+  }
+  async deleteMantaAuthContext(address, chain) {
+    return this.dbService.deleteMantaPayConfig(`authContext_${chain}_${address}`);
+  }
+  async saveLedgerState(palletName, network, data) {
+    try {
+      const suffix = this.currentAddress ? `_${this.currentAddress}` : '';
+      await this.dbService.setMantaPayData({
+        key: `storage_state_${palletName}_${network}${suffix}`,
+        ...data
+      });
+    } catch (e) {
+      console.error('manta-pay', e);
+      return false;
+    }
+    return true;
+  }
+  async getLedgerState(palletName, network) {
+    let result;
+    try {
+      const suffix = this.currentAddress ? `_${this.currentAddress}` : '';
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      result = await this.dbService.getMantaPayData(`storage_state_${palletName}_${network}${suffix}`);
+    } catch (e) {
+      console.error(e);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return result || null;
+  }
+  async initMantaPay(providerUrl, network) {
+    const networkParam = network.charAt(0).toUpperCase() + network.slice(1); // Manta || Calamari || Dolphin
+
+    const baseWallet = await BaseWallet.init({
+      apiEndpoint: providerUrl,
+      loggingEnabled: false,
+      provingFilePath: './manta-pay/proving',
+      parametersFilePath: './manta-pay/parameters',
+      saveStorageStateToLocal: this.saveLedgerState.bind(this),
+      getStorageStateFromLocal: this.getLedgerState.bind(this)
+    });
+    this._privateWallet = MantaPayWallet.init(networkParam, baseWallet);
+    return this._privateWallet.api;
+  }
+  async getCurrentLedgerState() {
+    var _this$_privateWallet;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const ledgerState = await this.getLedgerState('mantaPay', 'Calamari');
+    if (!ledgerState) {
+      return 0;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    return await ((_this$_privateWallet = this._privateWallet) === null || _this$_privateWallet === void 0 ? void 0 : _this$_privateWallet.getLedgerCurrentCount(ledgerState.checkpoint));
+  }
+  setSyncState(data) {
+    this.syncState = data;
+    this.syncStateSubject.next(this.syncState);
+  }
+  async subscribeSyncProgress() {
+    var _this$_privateWallet2;
+    const ledgerTotalCount = await ((_this$_privateWallet2 = this._privateWallet) === null || _this$_privateWallet2 === void 0 ? void 0 : _this$_privateWallet2.getLedgerTotalCount());
+    const interval = setInterval(() => {
+      this.getCurrentLedgerState().then(currentCount => {
+        const progress = Math.floor(currentCount / ledgerTotalCount * 100);
+        if (progress === 100) {
+          this.syncState = {
+            isSyncing: false,
+            progress
+          };
+          clearInterval(interval);
+        } else {
+          this.syncState = {
+            isSyncing: true,
+            progress
+          };
+        }
+        this.syncStateSubject.next(this.syncState);
+      }).catch(console.error);
+    }, 1000);
+    return () => {
+      interval && clearInterval(interval);
+    };
+  }
+}

package/services/chain-service/handler/types.d.ts

@@ -1,4 +1,5 @@
 import { MetadataItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ApiPromise } from '@polkadot/api';
 export interface _EvmChainSpec {
     evmChainId: number;
     name: string;
@@ -19,6 +20,7 @@ export interface _ApiOptions {
     providerName?: string;
     metadata?: MetadataItem;
     onUpdateStatus?: (isConnected: boolean) => void;
+    externalApiPromise?: ApiPromise;
 }
 export declare enum _CHAIN_VALIDATION_ERROR {
     INVALID_INFO_TYPE = "invalidInfoType",

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

@@ -1,6 +1,6 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
 import { AssetSetting, ValidateNetworkResponse } from '@subwallet/extension-base/background/KoniTypes';
-import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
+import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-service/handler/manta/MantaPrivateHandler';
 import { _ChainConnectionStatus, _ChainState, _NetworkUpsertParams, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { IMetadataItem } from '@subwallet/extension-base/services/storage-service/databases';
@@ -13,6 +13,8 @@ export declare class ChainService {
     private lockChainInfoMap;
     private substrateChainHandler;
     private evmChainHandler;
+    private mantaChainHandler;
+    get mantaPay(): MantaPrivateHandler;
     private chainInfoMapSubject;
     private chainStateMapSubject;
     private assetRegistrySubject;
@@ -25,8 +27,8 @@ export declare class ChainService {
     getXcmRefMap(): Record<string, _AssetRef>;
     getEvmApi(slug: string): import("./handler/EvmApi").EvmApi;
     getEvmApiMap(): Record<string, import("./handler/EvmApi").EvmApi>;
-    getSubstrateApiMap(): Record<string, SubstrateApi>;
-    getSubstrateApi(slug: string): SubstrateApi;
+    getSubstrateApiMap(): Record<string, import("./handler/SubstrateApi").SubstrateApi>;
+    getSubstrateApi(slug: string): import("./handler/SubstrateApi").SubstrateApi;
     getChainCurrentProviderByKey(slug: string): {
         endpoint: string;
         providerName: string;
@@ -54,6 +56,7 @@ export declare class ChainService {
     getChainInfoByKey(key: string): _ChainInfo;
     getActiveChainInfos(): Record<string, _ChainInfo>;
     getAssetBySlug(slug: string): _ChainAsset;
+    getMantaZkAssets(chain: string): Record<string, _ChainAsset>;
     getFungibleTokensByChain(chainSlug: string, checkActive?: boolean): Record<string, _ChainAsset>;
     getXcmEqualAssetByChain(destinationChainSlug: string, originTokenSlug: string): _ChainAsset | undefined;
     getAssetByChainAndType(chainSlug: string, assetTypes: _AssetType[]): Record<string, _ChainAsset>;
@@ -96,6 +99,7 @@ export declare class ChainService {
     checkAndUpdateStatusMapForChain(chainSlug: string): void;
     initAssetSettings(): Promise<void>;
     setAssetSettings(assetSettings: Record<string, AssetSetting>, emitEvent?: boolean): void;
+    setMantaZkAssetSettings(visible: boolean): void;
     getStoreAssetSettings(): Promise<Record<string, AssetSetting>>;
     getAssetSettings(): Promise<Record<string, AssetSetting>>;
     updateAssetSetting(assetSlug: string, assetSetting: AssetSetting, autoEnableNativeToken?: boolean): Promise<boolean | undefined>;

package/services/chain-service/index.js

@@ -3,12 +3,13 @@
 
 import { AssetLogoMap, AssetRefMap, ChainAssetMap, ChainInfoMap, ChainLogoMap, MultiChainAssetMap } from '@subwallet/chain-list';
 import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
-import { _ASSET_LOGO_MAP_SRC, _ASSET_REF_SRC, _CHAIN_ASSET_SRC, _CHAIN_INFO_SRC, _CHAIN_LOGO_MAP_SRC, _DEFAULT_ACTIVE_CHAINS, _MULTI_CHAIN_ASSET_SRC } from '@subwallet/extension-base/services/chain-service/constants';
+import { _ASSET_LOGO_MAP_SRC, _ASSET_REF_SRC, _CHAIN_ASSET_SRC, _CHAIN_INFO_SRC, _CHAIN_LOGO_MAP_SRC, _DEFAULT_ACTIVE_CHAINS, _MANTA_ZK_CHAIN_GROUP, _MULTI_CHAIN_ASSET_SRC, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { EvmChainHandler } from '@subwallet/extension-base/services/chain-service/handler/EvmChainHandler';
+import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-service/handler/manta/MantaPrivateHandler';
 import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isEqualContractAddress, _isEqualSmartContractAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey } from '@subwallet/extension-base/services/chain-service/utils';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
 import { BehaviorSubject, Subject } from 'rxjs';
 import Web3 from 'web3';
@@ -22,6 +23,10 @@ export class ChainService {
   };
   lockChainInfoMap = false; // prevent unwanted changes (edit, enable, disable) to chainInfoMap
 
+  get mantaPay() {
+    return this.mantaChainHandler;
+  }
+
   // TODO: consider BehaviorSubject
   chainInfoMapSubject = new Subject();
   chainStateMapSubject = new Subject();
@@ -35,6 +40,10 @@ export class ChainService {
   constructor(dbService, eventService) {
     this.dbService = dbService;
     this.eventService = eventService;
+    this.substrateChainHandler = new SubstrateChainHandler();
+    this.evmChainHandler = new EvmChainHandler();
+    this.mantaChainHandler = new MantaPrivateHandler(dbService);
+    this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
     this.chainStateMapSubject.next(this.dataMap.chainStateMap);
     this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
     this.assetRegistrySubject.next(this.dataMap.assetRegistry);
@@ -212,6 +221,15 @@ export class ChainService {
   getAssetBySlug(slug) {
     return this.getAssetRegistry()[slug];
   }
+  getMantaZkAssets(chain) {
+    const result = {};
+    Object.values(this.getAssetRegistry()).forEach(chainAsset => {
+      if (chainAsset.originChain === chain && _isAssetFungibleToken(chainAsset) && chainAsset.symbol.startsWith(_ZK_ASSET_PREFIX)) {
+        result[chainAsset.slug] = chainAsset;
+      }
+    });
+    return result;
+  }
   getFungibleTokensByChain(chainSlug, checkActive = false) {
     const result = {};
     const assetSettings = this.assetSettingSubject.value;
@@ -399,11 +417,21 @@ export class ChainService {
       }
     };
     if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
-      const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
-        providerName,
-        onUpdateStatus
-      });
-      this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
+      if (_MANTA_ZK_CHAIN_GROUP.includes(chainInfo.slug)) {
+        const apiPromise = await this.mantaChainHandler.initMantaPay(endpoint, chainInfo.slug);
+        const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
+          providerName,
+          externalApiPromise: apiPromise,
+          onUpdateStatus
+        });
+        this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
+      } else {
+        const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
+          providerName,
+          onUpdateStatus
+        });
+        this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
+      }
     }
     if (chainInfo.evmInfo !== null && chainInfo.evmInfo !== undefined) {
       const chainApi = await this.evmChainHandler.initApi(chainInfo.slug, endpoint, {
@@ -1161,6 +1189,27 @@ export class ChainService {
     });
     this.store.set('AssetSetting', assetSettings);
   }
+  setMantaZkAssetSettings(visible) {
+    const zkAssetSettings = {};
+    Object.values(this.dataMap.assetRegistry).forEach(asset => {
+      if (_isMantaZkAsset(asset)) {
+        zkAssetSettings[asset.slug] = {
+          visible
+        };
+      }
+    });
+    this.store.get('AssetSetting', storedAssetSettings => {
+      const newAssetSettings = {
+        ...storedAssetSettings,
+        ...zkAssetSettings
+      };
+      this.store.set('AssetSetting', newAssetSettings);
+      this.assetSettingSubject.next(newAssetSettings);
+      Object.keys(zkAssetSettings).forEach(slug => {
+        this.eventService.emit('asset.updateState', slug);
+      });
+    });
+  }
   async getStoreAssetSettings() {
     return new Promise(resolve => {
       this.store.get('AssetSetting', resolve);

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

@@ -65,3 +65,4 @@ export declare function _isCustomProvider(providerKey: string): boolean;
 export declare function _generateCustomProviderKey(index: number): string;
 export declare const findChainInfoByHalfGenesisHash: (chainMap: Record<string, _ChainInfo>, halfGenesisHash?: string) => _ChainInfo | null;
 export declare const findChainInfoByChainId: (chainMap: Record<string, _ChainInfo>, chainId?: number) => _ChainInfo | null;
+export declare function _isMantaZkAsset(chainAsset: _ChainAsset): boolean;

package/services/chain-service/utils.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _AssetRefPath, _AssetType, _SubstrateChainType } from '@subwallet/chain-list/types';
+import { _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _CUSTOM_PREFIX, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 export function _isCustomChain(slug) {
@@ -354,4 +355,7 @@ export const findChainInfoByChainId = (chainMap, chainId) => {
     }
   }
   return null;
-};
+};
+export function _isMantaZkAsset(chainAsset) {
+  return _MANTA_ZK_CHAIN_GROUP.includes(chainAsset.originChain) && chainAsset.symbol.startsWith(_ZK_ASSET_PREFIX);
+}

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

@@ -20,6 +20,9 @@ export interface EventRegistry {
     'transaction.failed': [SWTransaction | undefined];
     'transaction.submitStaking': [string];
     'transaction.transferNft': [SWTransaction | undefined];
+    'mantaPay.initSync': [string | undefined];
+    'mantaPay.submitTransaction': [SWTransaction | undefined];
+    'mantaPay.enable': [string];
 }
 export declare type EventType = keyof EventRegistry;
 export declare const COMMON_RELOAD_EVENTS: EventType[];

package/services/event-service/types.js

@@ -1,4 +1,6 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-export const COMMON_RELOAD_EVENTS = ['account.updateCurrent', 'asset.updateState', 'account.add', 'chain.updateState', 'account.remove', 'chain.add'];
+export const COMMON_RELOAD_EVENTS = ['account.updateCurrent', 'asset.updateState', 'account.add', 'chain.updateState', 'account.remove', 'chain.add', 'mantaPay.initSync',
+// TODO: re-check this
+'mantaPay.enable'];

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

@@ -1,9 +1,10 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
-import { BalanceItem, ChainStakingMetadata, CrowdloanItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, StakingType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { BalanceItem, ChainStakingMetadata, CrowdloanItem, MantaPayConfig, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, StakingType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { IBalance, IChain, INft } from '@subwallet/extension-base/services/storage-service/databases';
 import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
+import MantaPayStore from '@subwallet/extension-base/services/storage-service/db-stores/MantaPay';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import { HistoryQuery } from '@subwallet/extension-base/services/storage-service/db-stores/Transaction';
 import { Subscription } from 'dexie';
@@ -24,6 +25,7 @@ export default class DatabaseService {
         asset: AssetStore;
         chainStakingMetadata: ChainStakingMetadataStore;
         nominatorMetadata: NominatorMetadataStore;
+        mantaPay: MantaPayStore;
     };
     private logger;
     private nftSubscription;
@@ -67,4 +69,11 @@ export default class DatabaseService {
     updateNominatorMetadata(item: NominatorMetadata): Promise<unknown>;
     getNominatorMetadata(): Promise<NominatorMetadata[]>;
     resetWallet(resetAll: boolean): Promise<void>;
+    setMantaPayData(data: any): Promise<void>;
+    updateMantaPayData(key: string, data: Record<string, any>): Promise<void>;
+    getMantaPayData(key: string): Promise<any>;
+    deleteMantaPayConfig(key: string): Promise<number>;
+    subscribeMantaPayConfig(chain: string, callback: (data: MantaPayConfig[]) => void): void;
+    getMantaPayConfig(chain: string): Promise<any[]>;
+    getMantaPayFirstConfig(chain: string): Promise<any>;
 }

package/services/storage-service/DatabaseService.js

@@ -5,6 +5,7 @@ import { APIItemState, StakingType } from '@subwallet/extension-base/background/
 import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
 import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
+import MantaPayStore from '@subwallet/extension-base/services/storage-service/db-stores/MantaPay';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import { logger as createLogger } from '@polkadot/util';
@@ -32,7 +33,8 @@ export default class DatabaseService {
       asset: new AssetStore(this._db.asset),
       // staking
       chainStakingMetadata: new ChainStakingMetadataStore(this._db.chainStakingMetadata),
-      nominatorMetadata: new NominatorMetadataStore(this._db.nominatorMetadata)
+      nominatorMetadata: new NominatorMetadataStore(this._db.nominatorMetadata),
+      mantaPay: new MantaPayStore(this._db.mantaPay)
     };
   }
   async updatePriceStore(priceData) {
@@ -229,4 +231,32 @@ export default class DatabaseService {
       });
     });
   }
+  async setMantaPayData(data) {
+    await this._db.mantaPay.put(data); // just override if exist
+  }
+
+  async updateMantaPayData(key, data) {
+    await this._db.mantaPay.update(key, data); // just override if exist
+  }
+
+  async getMantaPayData(key) {
+    return this._db.mantaPay.get({
+      key
+    });
+  }
+  async deleteMantaPayConfig(key) {
+    return this.stores.mantaPay.deleteRecord(key);
+  }
+  subscribeMantaPayConfig(chain, callback) {
+    this.stores.mantaPay.subscribeMantaPayConfig(chain).subscribe({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      next: data => callback && callback(data)
+    });
+  }
+  async getMantaPayConfig(chain) {
+    return this.stores.mantaPay.getConfig(chain);
+  }
+  async getMantaPayFirstConfig(chain) {
+    return this.stores.mantaPay.getFirstConfig(chain);
+  }
 }

package/services/storage-service/databases/index.d.ts

@@ -28,6 +28,7 @@ export interface IMigration {
 }
 export interface IMetadataItem extends MetadataItem, DefaultChainDoc {
 }
+export declare type IMantaPayLedger = any;
 export default class KoniDatabase extends Dexie {
     price: Table<PriceJson, object>;
     balances: Table<IBalance, object>;
@@ -42,6 +43,7 @@ export default class KoniDatabase extends Dexie {
     asset: Table<_ChainAsset, object>;
     chainStakingMetadata: Table<ChainStakingMetadata, object>;
     nominatorMetadata: Table<NominatorMetadata, object>;
+    mantaPay: Table<IMantaPayLedger, object>;
     private schemaVersion;
     constructor(name?: string, schemaVersion?: number);
     private conditionalVersion;

package/services/storage-service/databases/index.js

@@ -27,6 +27,9 @@ export default class KoniDatabase extends Dexie {
     this.conditionalVersion(2, {
       metadata: 'genesisHash, chain'
     });
+    this.conditionalVersion(3, {
+      mantaPay: 'key, chain'
+    });
   }
   conditionalVersion(version, schema, upgrade) {
     if (this.schemaVersion != null && this.schemaVersion < version) {

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

@@ -0,0 +1,9 @@
+import { IMantaPayLedger } from '@subwallet/extension-base/services/storage-service/databases';
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+export default class MantaPayStore extends BaseStore<IMantaPayLedger> {
+    getAll(): Promise<any[]>;
+    subscribeMantaPayConfig(chain: string): import("dexie").Observable<any[]>;
+    getConfig(chain: string): import("dexie").PromiseExtended<any[]>;
+    getFirstConfig(chain: string): import("dexie").PromiseExtended<any>;
+    deleteRecord(key: string): import("dexie").PromiseExtended<number>;
+}

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

@@ -0,0 +1,32 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+import { liveQuery } from 'dexie';
+export default class MantaPayStore extends BaseStore {
+  async getAll() {
+    return this.table.toArray();
+  }
+  subscribeMantaPayConfig(chain) {
+    return liveQuery(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    () => this.table.where({
+      chain
+    }).filter(data => (data === null || data === void 0 ? void 0 : data.key) && (data === null || data === void 0 ? void 0 : data.key.startsWith('config'))).toArray());
+  }
+  getConfig(chain) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    return this.table.where({
+      chain
+    }).filter(data => (data === null || data === void 0 ? void 0 : data.key) && (data === null || data === void 0 ? void 0 : data.key.startsWith('config'))).toArray();
+  }
+  getFirstConfig(chain) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    return this.table.where({
+      chain
+    }).filter(data => (data === null || data === void 0 ? void 0 : data.key) && (data === null || data === void 0 ? void 0 : data.key.startsWith('config'))).first();
+  }
+  deleteRecord(key) {
+    return this.table.where('key').equals(key).delete();
+  }
+}

package/utils/index.d.ts

@@ -40,3 +40,4 @@ export declare function waitTimeout(ms: number): Promise<void>;
 export declare const stripUrl: (url: string) => string;
 export * from './array';
 export * from './environment';
+export * from './lazy';

package/utils/index.js

@@ -285,4 +285,5 @@ export const stripUrl = url => {
   return parts[2];
 };
 export * from "./array.js";
-export * from "./environment.js";
+export * from "./environment.js";
+export * from "./lazy.js";

package/utils/lazy.d.ts

@@ -0,0 +1,2 @@
+export declare function removeLazy(key: string): void;
+export declare function addLazy(key: string, callback: () => void, lazyTime?: number, maxLazyTime?: number): void;

package/utils/lazy.js

@@ -0,0 +1,43 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const lazyMap = {};
+export function removeLazy(key) {
+  if (lazyMap[key]) {
+    clearTimeout(lazyMap[key].timeout);
+    delete lazyMap[key];
+  }
+}
+
+// Add or update new lazy thread
+export function addLazy(key, callback, lazyTime = 300, maxLazyTime = 3000) {
+  const existed = lazyMap[key];
+  const now = new Date().getTime();
+  if (existed) {
+    clearTimeout(existed.timeout);
+    lazyMap[key] = {
+      ...existed,
+      callback
+    };
+
+    // Fire callback if last fire is too long
+    if (now - existed.lastFire >= maxLazyTime) {
+      callback();
+      lazyMap[key].lastFire = now;
+    } else {
+      lazyMap[key].timeout = setTimeout(() => {
+        // This will be fire in the last call of lazy thread
+        callback();
+        lazyMap[key].lastFire = new Date().getTime();
+        removeLazy(key);
+      }, lazyTime);
+    }
+  } else {
+    // Fire callback immediately in the first time
+    callback();
+    lazyMap[key] = {
+      callback,
+      lastFire: now
+    };
+  }
+}