@subwallet/extension-base 0.8.4-0 → 1.0.1

package/services/storage-service/DatabaseService.js

@@ -0,0 +1,219 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
+import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, 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 NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
+import { logger as createLogger } from '@polkadot/util';
+export default class DatabaseService {
+  // TODO: might remove this
+
+  constructor() {
+    this.logger = createLogger('DB-Service');
+    this._db = new KoniDatabase();
+    this.stores = {
+      price: new PriceStore(this._db.price),
+      balance: new BalanceStore(this._db.balances),
+      nft: new NftStore(this._db.nfts),
+      nftCollection: new NftCollectionStore(this._db.nftCollections),
+      crowdloan: new CrowdloanStore(this._db.crowdloans),
+      staking: new StakingStore(this._db.stakings),
+      transaction: new TransactionStore(this._db.transactions),
+      migration: new MigrationStore(this._db.migrations),
+      chain: new ChainStore(this._db.chain),
+      asset: new AssetStore(this._db.asset),
+      // staking
+      chainStakingMetadata: new ChainStakingMetadataStore(this._db.chainStakingMetadata),
+      nominatorMetadata: new NominatorMetadataStore(this._db.nominatorMetadata)
+    };
+  }
+  async updatePriceStore(priceData) {
+    await this.stores.price.table.put(priceData);
+  }
+  async getPriceStore() {
+    try {
+      const rs = await this.stores.price.table.get('usd');
+      return rs;
+    } catch (e) {
+      return undefined;
+    }
+  }
+
+  // Balance
+  async getStoredBalance() {
+    return this.stores.balance.table.toArray();
+  }
+  async updateBalanceStore(address, item) {
+    if (item.state === APIItemState.READY) {
+      this.logger.log(`Updating balance for [${item.tokenSlug}]`);
+      return this.stores.balance.upsert({
+        address,
+        ...item
+      });
+    }
+  }
+  async removeFromBalanceStore(assets) {
+    this.logger.log('Bulk removing AssetStore');
+    return this.stores.balance.removeBySlugs(assets);
+  }
+
+  // Crowdloan
+  async updateCrowdloanStore(chain, address, item) {
+    if (item.state === APIItemState.READY && item.contribute !== '0') {
+      this.logger.log(`Updating crowdloan for [${chain}]`);
+      return this.stores.crowdloan.upsert({
+        chain,
+        address,
+        ...item
+      });
+    } else {
+      this.logger.debug(`Removing crowdloan for [${chain}]`);
+      return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
+    }
+  }
+
+  // Staking
+  async updateStaking(chain, address, item) {
+    if (item.state === APIItemState.READY) {
+      this.logger.log(`Updating staking for [${chain}]`);
+      return this.stores.staking.upsert(item);
+    }
+  }
+  async getStakings(addresses, chains) {
+    const stakings = await this.stores.staking.getStakings(addresses, chains);
+    this.logger.log('Get Stakings: ', stakings);
+    return stakings;
+  }
+  async getStakingsByChains(chains) {
+    return this.stores.staking.getStakingsByChains(chains);
+  }
+  async getPooledStakings(addresses, chainHashes) {
+    const stakings = await this.stores.staking.getPooledStakings(addresses, chainHashes);
+    this.logger.log('Get Pooled Stakings: ', stakings);
+    return stakings;
+  }
+  subscribeStaking(addresses, chainList, callback) {
+    this.stakingSubscription && this.stakingSubscription.unsubscribe();
+    this.stakingSubscription = this.stores.staking.subscribeStaking(addresses, chainList).subscribe({
+      next: stakings => callback && callback(stakings)
+    });
+    return this.stakingSubscription;
+  }
+  subscribeChainStakingMetadata(chains, callback) {
+    this.stores.chainStakingMetadata.subscribeByChain(chains).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+  subscribeNominatorMetadata(callback) {
+    this.stores.nominatorMetadata.subscribeAll().subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+
+  // Transaction histories
+  async getHistories(query) {
+    const histories = await this.stores.transaction.queryHistory(query);
+    this.logger.log('Get histories: ', histories);
+    return histories;
+  }
+  async upsertHistory(histories) {
+    this.logger.log('Updating transaction histories');
+    return this.stores.transaction.bulkUpsert(histories);
+  }
+
+  // NFT Collection
+  async addNftCollection(collection) {
+    this.logger.log(`Updating NFT collection for [${collection.chain}]`);
+    return this.stores.nftCollection.upsert(collection);
+  }
+  async deleteNftCollection(chain, collectionId) {
+    await this.stores.nftCollection.removeCollection(chain, collectionId);
+    await this.stores.nft.deleteNftsByCollection(chain, collectionId);
+  }
+  getAllNftCollection(chainHashes) {
+    return this.stores.nftCollection.getNftCollection(chainHashes);
+  }
+
+  // NFT
+  subscribeNft(addresses, chainHashes, callback) {
+    this.nftSubscription && this.nftSubscription.unsubscribe();
+    this.nftSubscription = this.stores.nft.subscribeNft(addresses, chainHashes).subscribe({
+      next: nfts => callback && callback(nfts)
+    });
+    return this.nftSubscription;
+  }
+  async getNft(addresses, chainHashes) {
+    const nfts = await this.stores.nft.getNft(addresses, chainHashes);
+    this.logger.log('Get NFTs: ', nfts);
+    return nfts;
+  }
+  async addNft(address, nft) {
+    this.logger.log(`Updating NFT for [${nft.chain}]`);
+    return this.stores.nft.upsert({
+      ...nft,
+      address
+    });
+  }
+  handleNftTransfer(chain, addresses, nftItem) {
+    return this.stores.nft.deleteNftByAddresses(chain, addresses, nftItem);
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    this.logger.log(`Remove NFTs [${nftIds.join(', ')}]`);
+    return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
+  }
+
+  // Chain
+  async updateChainStore(item) {
+    this.logger.log(`Updating storageInfo for chain [${item.slug}]`);
+    return this.stores.chain.upsert(item);
+  }
+  async bulkUpdateChainStore(data) {
+    this.logger.log('Bulk updating ChainStore');
+    return this.stores.chain.bulkUpsert(data);
+  }
+  async removeFromChainStore(chains) {
+    this.logger.log('Bulk removing ChainStore');
+    return this.stores.chain.removeChains(chains);
+  }
+  async getAllChainStore() {
+    const allChains = await this.stores.chain.getAll();
+    this.logger.log('Get all chains: ', allChains);
+    return allChains;
+  }
+
+  // Asset
+  async updateAssetStore(item) {
+    this.logger.log(`Updating storageInfo for chainAsset [${item.originChain}]`);
+    return this.stores.asset.upsert(item);
+  }
+  async getAllAssetStore() {
+    const allAssets = await this.stores.asset.getAll();
+    this.logger.log('Get all stored assets: ', allAssets);
+    return allAssets;
+  }
+  async removeFromAssetStore(items) {
+    this.logger.log('Bulk removing AssetStore');
+    return this.stores.asset.removeAssets(items);
+  }
+
+  // Staking
+  async updateChainStakingMetadata(item) {
+    this.logger.log('Update ChainStakingMetadata: ', item.chain);
+    return this.stores.chainStakingMetadata.upsert(item);
+  }
+  async getChainStakingMetadata() {
+    return this.stores.chainStakingMetadata.getAll();
+  }
+  async getStakingMetadataByChain(chain, type = StakingType.NOMINATED) {
+    return this.stores.chainStakingMetadata.getByChainAndType(chain, type);
+  }
+  async updateNominatorMetadata(item) {
+    this.logger.log('Update NominatorMetadata: ', item.address, item.chain);
+    return this.stores.nominatorMetadata.upsert(item);
+  }
+  async getNominatorMetadata() {
+    return this.stores.nominatorMetadata.getAll();
+  }
+}

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

@@ -0,0 +1,45 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { BalanceItem, ChainStakingMetadata, CrowdloanItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import Dexie, { Table } from 'dexie';
+export interface DefaultChainDoc {
+    chain: string;
+}
+export interface DefaultAddressDoc {
+    address: string;
+}
+export interface DefaultDocWithAddressAndChain extends DefaultChainDoc, DefaultAddressDoc {
+}
+export interface IBalance extends BalanceItem, DefaultAddressDoc {
+}
+export interface IChain extends _ChainInfo {
+    active: boolean;
+    currentProvider: string;
+}
+export interface ICrowdloanItem extends CrowdloanItem, DefaultAddressDoc, DefaultChainDoc {
+}
+export interface INft extends NftItem, DefaultAddressDoc {
+}
+export interface ITransactionHistoryItem extends TransactionHistoryItem, DefaultAddressDoc, DefaultChainDoc {
+}
+export interface IMigration {
+    key: string;
+    name: string;
+    timestamp: number;
+}
+export default class KoniDatabase extends Dexie {
+    price: Table<PriceJson, object>;
+    balances: Table<IBalance, object>;
+    nfts: Table<INft, object>;
+    nftCollections: Table<NftCollection, object>;
+    crowdloans: Table<ICrowdloanItem, object>;
+    stakings: Table<StakingItem, object>;
+    transactions: Table<ITransactionHistoryItem, object>;
+    migrations: Table<IMigration, object>;
+    chain: Table<IChain, object>;
+    asset: Table<_ChainAsset, object>;
+    chainStakingMetadata: Table<ChainStakingMetadata, object>;
+    nominatorMetadata: Table<NominatorMetadata, object>;
+    private schemaVersion;
+    constructor(name?: string, schemaVersion?: number);
+    private conditionalVersion;
+}

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

@@ -0,0 +1,37 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Dexie from 'dexie';
+const DEFAULT_DATABASE = 'SubWalletDB_v2';
+export default class KoniDatabase extends Dexie {
+  constructor(name = DEFAULT_DATABASE, schemaVersion = 9) {
+    super(name);
+    this.schemaVersion = schemaVersion;
+    this.conditionalVersion(1, {
+      // DO NOT declare all columns, only declare properties to be indexed
+      // Read more: https://dexie.org/docs/Version/Version.stores()
+      // Primary key is always the first entry
+      chain: 'slug',
+      asset: 'slug',
+      price: 'currency',
+      balances: '[tokenSlug+address], tokenSlug, address',
+      nfts: '[chain+address+collectionId+id], [address+chain], chain, id, address, collectionId, name',
+      nftCollections: '[chain+collectionId], chain, collectionId, collectionName',
+      crowdloans: '[chain+address], chain, address',
+      stakings: '[chain+address+type], [chain+address], chain, address, type',
+      transactions: '[chain+address+extrinsicHash], &[chain+address+extrinsicHash], chain, address, extrinsicHash, action',
+      migrations: '[key+name]',
+      chainStakingMetadata: '[chain+type], chain, type',
+      nominatorMetadata: '[chain+address+type], [chain+address], chain, address, type'
+    });
+  }
+  conditionalVersion(version, schema, upgrade) {
+    if (this.schemaVersion != null && this.schemaVersion < version) {
+      return;
+    }
+    const dexieVersion = this.version(version).stores(schema);
+    if (upgrade != null) {
+      dexieVersion.upgrade(upgrade);
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+export default class AssetStore extends BaseStore<_ChainAsset> {
+    getAll(): Promise<_ChainAsset[]>;
+    removeAssets(keys: string[]): Promise<number>;
+}

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

@@ -0,0 +1,12 @@
+// 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';
+export default class AssetStore extends BaseStore {
+  async getAll() {
+    return this.table.toArray();
+  }
+  async removeAssets(keys) {
+    return this.table.where('slug').anyOfIgnoreCase(keys).delete();
+  }
+}

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

@@ -0,0 +1,7 @@
+import { BalanceItem } from '@subwallet/extension-base/background/KoniTypes';
+import { IBalance } from '../databases';
+import BaseStoreWithAddress from '../db-stores/BaseStoreWithAddress';
+export default class BalanceStore extends BaseStoreWithAddress<IBalance> {
+    getBalanceMapByAddress(address: string): Promise<Record<string, BalanceItem>>;
+    removeBySlugs(tokenSlugs: string[]): Promise<number>;
+}

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

@@ -0,0 +1,24 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithAddress from "./BaseStoreWithAddress.js";
+export default class BalanceStore extends BaseStoreWithAddress {
+  async getBalanceMapByAddress(address) {
+    const data = await this.table.where('address').equals(address).toArray();
+    const balanceMap = {};
+    data.forEach(storedBalance => {
+      balanceMap[storedBalance.tokenSlug] = {
+        tokenSlug: storedBalance.tokenSlug,
+        state: storedBalance.state,
+        free: storedBalance.free,
+        locked: storedBalance.locked,
+        substrateInfo: storedBalance.substrateInfo,
+        timestamp: storedBalance.timestamp
+      };
+    });
+    return balanceMap;
+  }
+  async removeBySlugs(tokenSlugs) {
+    return this.table.where('tokenSlug').anyOfIgnoreCase(tokenSlugs).delete();
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Table } from 'dexie';
+import { Logger } from '@polkadot/util/types';
+export default class BaseStore<T> {
+    private _table;
+    logger: Logger;
+    constructor(table: Table<T, unknown>);
+    get table(): Table<T, unknown>;
+    upsert(record: T): Promise<unknown>;
+    bulkUpsert(records: T[]): Promise<unknown>;
+    remove(record: T): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { logger as createLogger } from '@polkadot/util';
+export default class BaseStore {
+  constructor(table) {
+    this._table = table;
+    this.logger = createLogger(this.constructor.name);
+  }
+  get table() {
+    return this._table;
+  }
+  upsert(record) {
+    return this.table.put(record);
+  }
+  bulkUpsert(records) {
+    return this.table.bulkPut(records);
+  }
+  remove(record) {
+    return this.table.delete(record);
+  }
+}

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

@@ -0,0 +1,5 @@
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+import { DefaultAddressDoc } from '../databases';
+export default class BaseStoreWithAddress<T extends DefaultAddressDoc> extends BaseStore<T> {
+    removeAllByAddress(address: string): import("dexie").PromiseExtended<number>;
+}

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

@@ -0,0 +1,20 @@
+// 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';
+export default class BaseStoreWithAddress extends BaseStore {
+  removeAllByAddress(address) {
+    const conditions = {
+      address
+    };
+    return this.table.where(conditions).delete();
+  }
+
+  // async getDataByAddressAsObject (address: string) {
+  //   const data = await this.table.where('address').equals(address).toArray();
+  //
+  //   console.log('from store', data);
+  //
+  //   return {};
+  // }
+}

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

@@ -0,0 +1,7 @@
+import { DefaultDocWithAddressAndChain } from '@subwallet/extension-base/services/storage-service/databases';
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+export default class BaseStoreWithAddressAndChain<T extends DefaultDocWithAddressAndChain> extends BaseStore<T> {
+    convertToJsonObject(items: T[]): Record<string, T>;
+    removeAllByAddress(address: string, chain?: string): import("dexie").PromiseExtended<number>;
+    getDataByAddressAsObject(address: string): Promise<Record<string, T>>;
+}

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

@@ -0,0 +1,25 @@
+// 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';
+export default class BaseStoreWithAddressAndChain extends BaseStore {
+  convertToJsonObject(items) {
+    return items.reduce((a, v) => ({
+      ...a,
+      [v.chain]: v
+    }), {});
+  }
+  removeAllByAddress(address, chain) {
+    const conditions = {
+      address
+    };
+    if (chain) {
+      conditions.chain = chain;
+    }
+    return this.table.where(conditions).delete();
+  }
+  async getDataByAddressAsObject(address) {
+    const data = await this.table.where('address').equals(address).toArray();
+    return this.convertToJsonObject(data);
+  }
+}

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

@@ -0,0 +1,5 @@
+import { DefaultChainDoc } from '../databases';
+import BaseStore from './BaseStore';
+export default class BaseStoreWithChain<T extends DefaultChainDoc> extends BaseStore<T> {
+    convertToJsonObject(items: T[]): Record<string, T>;
+}

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

@@ -0,0 +1,12 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from "./BaseStore.js";
+export default class BaseStoreWithChain extends BaseStore {
+  convertToJsonObject(items) {
+    return items.reduce((a, v) => ({
+      ...a,
+      [v.chain]: v
+    }), {});
+  }
+}

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

@@ -0,0 +1,6 @@
+import { IChain } from '@subwallet/extension-base/services/storage-service/databases';
+import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+export default class ChainStore extends BaseStore<IChain> {
+    getAll(): Promise<IChain[]>;
+    removeChains(chains: string[]): Promise<number>;
+}

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

@@ -0,0 +1,12 @@
+// 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';
+export default class ChainStore extends BaseStore {
+  async getAll() {
+    return this.table.toArray();
+  }
+  async removeChains(chains) {
+    return this.table.where('slug').anyOfIgnoreCase(chains).delete();
+  }
+}

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

@@ -0,0 +1,9 @@
+import { ChainStakingMetadata, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithChain';
+export default class ChainStakingMetadataStore extends BaseStoreWithChain<ChainStakingMetadata> {
+    getAll(): Promise<ChainStakingMetadata[]>;
+    subscribeByChain(chains: string[]): import("dexie").Observable<ChainStakingMetadata[]>;
+    getByChains(chains: string[]): Promise<ChainStakingMetadata[]>;
+    getByChainAndType(chain: string, type?: StakingType): import("dexie").PromiseExtended<ChainStakingMetadata | undefined>;
+    removeByChains(chains: string[]): Promise<number>;
+}

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

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithChain';
+import { liveQuery } from 'dexie';
+export default class ChainStakingMetadataStore extends BaseStoreWithChain {
+  async getAll() {
+    return this.table.toArray();
+  }
+  subscribeByChain(chains) {
+    return liveQuery(() => this.getByChains(chains));
+  }
+  getByChains(chains) {
+    if (chains.length === 0) {
+      return this.getAll();
+    }
+    return this.table.where('chain').anyOfIgnoreCase(chains).toArray();
+  }
+  getByChainAndType(chain, type = StakingType.NOMINATED) {
+    return this.table.where({
+      chain,
+      type
+    }).first();
+  }
+  async removeByChains(chains) {
+    return this.table.where('chain').anyOfIgnoreCase(chains).delete();
+  }
+}

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

@@ -0,0 +1,6 @@
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { ICrowdloanItem } from '../databases';
+export default class CrowdloanStore extends BaseStoreWithAddressAndChain<ICrowdloanItem> {
+    getCrowdloan(address: string): import("dexie").PromiseExtended<ICrowdloanItem[]>;
+    deleteByChainAndAddress(chain: string, address: string): import("dexie").PromiseExtended<number>;
+}

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

@@ -0,0 +1,15 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+export default class CrowdloanStore extends BaseStoreWithAddressAndChain {
+  getCrowdloan(address) {
+    return this.table.where('address').equals(address).toArray();
+  }
+  deleteByChainAndAddress(chain, address) {
+    return this.table.where({
+      chain,
+      address
+    }).delete();
+  }
+}

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

@@ -0,0 +1,4 @@
+import { IMigration } from '../databases';
+import BaseStore from './BaseStore';
+export default class MigrationStore extends BaseStore<IMigration> {
+}

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

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from "./BaseStore.js";
+export default class MigrationStore extends BaseStore {}

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

@@ -0,0 +1,12 @@
+import { NftItem } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { INft } from '../databases';
+export default class NftStore extends BaseStoreWithAddressAndChain<INft> {
+    getNft(addresses: string[], chainList?: string[]): import("dexie").PromiseExtended<INft[]>;
+    subscribeNft(addresses: string[], chainList?: string[]): import("dexie").Observable<INft[]>;
+    deleteRemovedNftsFromCollection(chainHash: string, address: string, collection?: string, nftIds?: string[]): void | import("dexie").PromiseExtended<number>;
+    deleteNftsFromRemovedCollection(chain: string, address: string, collectionIds: string[]): import("dexie").Collection<INft, unknown>;
+    deleteNftByAddresses(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
+    deleteNftsByCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;
+    removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
+}

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

@@ -0,0 +1,61 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { liveQuery } from 'dexie';
+export default class NftStore extends BaseStoreWithAddressAndChain {
+  getNft(addresses, chainList = []) {
+    if (addresses.length) {
+      return this.table.where('address').anyOfIgnoreCase(addresses).and(item => !chainList.length || chainList.includes(item.chain)).toArray();
+    }
+
+    // return this.table.filter((item) => !chainHashes.length || chainHashes.includes(item.chainHash)).toArray();
+    return this.table.filter(item => !chainList.length || chainList.includes(item.chain)).toArray();
+  }
+  subscribeNft(addresses, chainList = []) {
+    return liveQuery(() => this.getNft(addresses, chainList));
+  }
+  deleteRemovedNftsFromCollection(chainHash, address, collection, nftIds = []) {
+    const conditions = {
+      chainHash,
+      address
+    };
+    if (!collection && nftIds && nftIds.length) {
+      return this.logger.warn('Missing collection id');
+    }
+    if (collection) {
+      conditions.collectionId = collection;
+    }
+    return this.table.where(conditions).and(item => !nftIds.some(nft => nft === item.id)).delete();
+  }
+  deleteNftsFromRemovedCollection(chain, address, collectionIds) {
+    return this.table.where({
+      address,
+      chain
+    }).and(nft => !collectionIds.some(item => item === nft.collectionId));
+  }
+  deleteNftByAddresses(chain, addresses, nftItem) {
+    return this.table.where('address').anyOfIgnoreCase(addresses).filter(storedItem => storedItem.chain === chain && storedItem.collectionId === nftItem.collectionId && storedItem.id === nftItem.id).delete();
+  }
+  deleteNftsByCollection(chain, collectionId) {
+    return this.table.where({
+      chain,
+      collectionId
+    }).delete();
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    return this.table.where({
+      chain,
+      address,
+      collectionId
+    }).filter(item => nftIds.includes(item.id || '')).delete();
+  }
+
+  // reformatCollectionIds (items: INft[]) {
+  //   return items.map((item) => {
+  //     item.collectionId = item.collectionId?.toLowerCase();
+
+  //     return item;
+  //   });
+  // }
+}

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

@@ -0,0 +1,7 @@
+import { NftCollection } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithChain from './BaseStoreWithChain';
+export default class NftCollectionStore extends BaseStoreWithChain<NftCollection> {
+    subscribeNftCollection(chains?: string[]): import("dexie").Observable<NftCollection[]>;
+    getNftCollection(chainList?: string[]): import("dexie").PromiseExtended<NftCollection[]>;
+    removeCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;
+}