@subwallet/extension-base 1.2.23-0 → 1.2.24-1

package/services/mkt-campaign-service/index.js

@@ -0,0 +1,275 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _getAssetDecimals, _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { MktCampaignConditionTypeValue } from '@subwallet/extension-base/services/mkt-campaign-service/types';
+import { fetchStaticData, TARGET_ENV, wait } from '@subwallet/extension-base/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import { BehaviorSubject } from 'rxjs';
+export default class MktCampaignService {
+  #state;
+  appPopupSubject = new BehaviorSubject([]);
+  appBannerSubject = new BehaviorSubject([]);
+  appConfirmationSubject = new BehaviorSubject([]);
+  constructor(state) {
+    this.#state = state;
+    this.appPopupSubject.next([]);
+    this.appBannerSubject.next([]);
+    this.appConfirmationSubject.next([]);
+    this.fetchPopupData().catch(e => {
+      console.error('Error on fetch popup', e);
+    });
+    this.fetchBannerData().catch(e => {
+      console.error('Error on fetch banner', e);
+    });
+    this.fetchConfirmationData().catch(e => {
+      console.error('Error on fetch confirmation', e);
+    });
+  }
+  fetchMktCampaignData(timeout = 10000) {
+    wait(timeout).finally(() => {
+      this.fetchPopupData().catch(console.error);
+      this.fetchBannerData().catch(console.error);
+      this.fetchConfirmationData().catch(console.error);
+    });
+  }
+  init() {
+    this.fetchMktCampaignData();
+    console.log('Mkt campaign service ready');
+  }
+  async fetchPopupData() {
+    const respAppPopupData = await fetchStaticData('app-popups');
+    const result = await this.handleMktCampaignData(respAppPopupData);
+    this.appPopupSubject.next(result);
+  }
+  async fetchBannerData() {
+    const respAppBannerData = await fetchStaticData('app-banners');
+    const result = await this.handleMktCampaignData(respAppBannerData);
+    this.appBannerSubject.next(result);
+  }
+  async fetchConfirmationData() {
+    const respAppConfirmationData = await fetchStaticData('app-confirmations');
+    const result = await this.handleMktCampaignData(respAppConfirmationData);
+    this.appConfirmationSubject.next(result);
+  }
+  subscribePopupsData(callback) {
+    return this.appPopupSubject.subscribe({
+      next: callback
+    });
+  }
+  subscribeBannersData(callback) {
+    return this.appBannerSubject.subscribe({
+      next: callback
+    });
+  }
+  subscribeConfirmationsData(callback) {
+    return this.appConfirmationSubject.subscribe({
+      next: callback
+    });
+  }
+  getAppPopupsData() {
+    return this.appPopupSubject.getValue();
+  }
+  getAppBannersData() {
+    return this.appBannerSubject.getValue();
+  }
+  getAppConfirmationsData() {
+    return this.appConfirmationSubject.getValue();
+  }
+  async handleMktCampaignData(data) {
+    const addresses = keyring.getPairs().map(pair => pair.address);
+    const allConditions = this.getAllConditions(data);
+    const conditionBalanceMap = await this.checkBalanceCondition(allConditions, addresses);
+    const conditionEarningMap = await this.checkEarningCondition(allConditions, addresses);
+    const conditionNftMap = await this.checkNftCondition(allConditions, addresses);
+    const conditionCrowdloanMap = await this.checkCrowdloanCondition(allConditions, addresses);
+    const conditionHasMoneyMap = await this.checkHasMoneyCondition(allConditions, addresses);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const conditionMap = Object.assign({}, conditionBalanceMap, conditionEarningMap, conditionNftMap, conditionCrowdloanMap, conditionHasMoneyMap);
+    const filteredData = this.checkActiveAndPlatformCondition(data);
+    return filteredData.filter(item => this.filterCampaignFunc(item, conditionMap));
+  }
+  checkActiveAndPlatformCondition(data) {
+    return data.filter(item => {
+      if (item.info) {
+        return this.checkCampaignExistTime(item.info) && item.info.platforms.includes(TARGET_ENV);
+      } else {
+        return true;
+      }
+    });
+  }
+  checkCampaignExistTime(info) {
+    if (info.start_time && info.stop_time) {
+      const now = new Date();
+      const startTime = new Date(info.start_time);
+      const endTime = new Date(info.stop_time);
+      return now >= startTime && now <= endTime;
+    } else {
+      return false;
+    }
+  }
+  async checkBalanceCondition(allConditions, addresses) {
+    var _allConditions$MktCam;
+    const allBalanceConditions = (_allConditions$MktCam = allConditions[MktCampaignConditionTypeValue.BALANCE]) === null || _allConditions$MktCam === void 0 ? void 0 : _allConditions$MktCam.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allBalanceConditionPromises = [];
+    allBalanceConditions.forEach(balanceCondition => {
+      const decimals = _getAssetDecimals(this.#state.getAssetBySlug(balanceCondition.chain_asset));
+      const convertedValue = new BigN(balanceCondition.value).shiftedBy(decimals);
+      allBalanceConditionPromises.push(this.#state.dbService.checkBalanceByTokens([balanceCondition.chain_asset], balanceCondition.comparison, addresses, convertedValue.toString()));
+    });
+    const promiseBalanceResult = await Promise.all(allBalanceConditionPromises);
+    const conditionBalanceMap = {};
+    promiseBalanceResult.forEach((rs, i) => {
+      conditionBalanceMap[allConditions[MktCampaignConditionTypeValue.BALANCE][i]] = rs > 0;
+    });
+    return conditionBalanceMap;
+  }
+  async checkEarningCondition(allConditions, addresses) {
+    var _allConditions$MktCam2;
+    const allEarningConditions = (_allConditions$MktCam2 = allConditions[MktCampaignConditionTypeValue.EARNING]) === null || _allConditions$MktCam2 === void 0 ? void 0 : _allConditions$MktCam2.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allEarningConditionPromises = [];
+    allEarningConditions.forEach(earningCondition => {
+      const poolSlugSplittedArr = earningCondition.pool_slug.split('___');
+      if (poolSlugSplittedArr[1] === 'liquid_staking') {
+        allEarningConditionPromises.push(new Promise(() => false));
+      }
+      const chain = earningCondition.pool_slug.split('___')[2];
+      const chainInfo = this.#state.getChainInfo(chain);
+      const {
+        decimals
+      } = _getChainNativeTokenBasicInfo(chainInfo);
+      const convertedValue = new BigN(earningCondition.value).shiftedBy(decimals);
+      allEarningConditionPromises.push(this.#state.dbService.checkEarningByTokens(earningCondition.pool_slug, earningCondition.comparison, addresses, convertedValue.toString()));
+    });
+    const promiseEarningResult = await Promise.all(allEarningConditionPromises);
+    const conditionEarningMap = {};
+    promiseEarningResult.forEach((rs, i) => {
+      conditionEarningMap[allConditions[MktCampaignConditionTypeValue.EARNING][i]] = rs > 0;
+    });
+    return conditionEarningMap;
+  }
+  async checkNftCondition(allConditions, addresses) {
+    var _allConditions$MktCam3;
+    const allNftConditions = (_allConditions$MktCam3 = allConditions[MktCampaignConditionTypeValue.NFT]) === null || _allConditions$MktCam3 === void 0 ? void 0 : _allConditions$MktCam3.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allNftConditionPromises = [];
+    allNftConditions.forEach(nftCondition => {
+      allNftConditionPromises.push(this.#state.dbService.checkNftByTokens(nftCondition.chain, addresses, nftCondition.collection_id));
+    });
+    const promiseNftResult = await Promise.all(allNftConditionPromises);
+    const conditionNftMap = {};
+    promiseNftResult.forEach((rs, i) => {
+      conditionNftMap[allConditions[MktCampaignConditionTypeValue.NFT][i]] = rs > 0;
+    });
+    return conditionNftMap;
+  }
+  async checkCrowdloanCondition(allConditions, addresses) {
+    var _allConditions$MktCam4;
+    const allCrowdloanConditions = (_allConditions$MktCam4 = allConditions[MktCampaignConditionTypeValue.CROWDLOAN]) === null || _allConditions$MktCam4 === void 0 ? void 0 : _allConditions$MktCam4.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allCrowdloanConditionPromises = [];
+    allCrowdloanConditions.forEach(crowdloanCondition => {
+      allCrowdloanConditionPromises.push(this.#state.dbService.checkCrowdloanByChain(crowdloanCondition.chain, addresses));
+    });
+    const promiseCrowdloanResult = await Promise.all(allCrowdloanConditionPromises);
+    const conditionCrowdloanMap = {};
+    promiseCrowdloanResult.forEach((rs, i) => {
+      conditionCrowdloanMap[allConditions[MktCampaignConditionTypeValue.CROWDLOAN][i]] = rs > 0;
+    });
+    return conditionCrowdloanMap;
+  }
+  async checkHasMoneyCondition(allConditions, addresses) {
+    const hasMoneyCondition = allConditions[MktCampaignConditionTypeValue.HAS_MONEY];
+    const allHasMoneyConditions = hasMoneyCondition === null || hasMoneyCondition === void 0 ? void 0 : hasMoneyCondition.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allHasMoneyConditionPromises = [];
+    allHasMoneyConditions.forEach(hasMoneyCondition => {
+      allHasMoneyConditionPromises.push(this.#state.dbService.checkHasMoneyByTokens(hasMoneyCondition.has_money, addresses));
+    });
+    const promiseHasMoneyResult = await Promise.all(allHasMoneyConditionPromises);
+    const conditionHasMoneyMap = {};
+    promiseHasMoneyResult.forEach((rs, i) => {
+      conditionHasMoneyMap[hasMoneyCondition[i]] = rs > 0;
+    });
+    return conditionHasMoneyMap;
+  }
+  getAllConditions(respAppPopupData) {
+    const result = {
+      [MktCampaignConditionTypeValue.BALANCE]: [],
+      [MktCampaignConditionTypeValue.EARNING]: [],
+      [MktCampaignConditionTypeValue.CROWDLOAN]: [],
+      [MktCampaignConditionTypeValue.NFT]: [],
+      [MktCampaignConditionTypeValue.HAS_MONEY]: []
+    };
+    const getConditionByType = (campaignCondition, type) => {
+      const campaignConditionByType = campaignCondition[type];
+      campaignConditionByType === null || campaignConditionByType === void 0 ? void 0 : campaignConditionByType.forEach(condition => {
+        const conditionStringify = JSON.stringify(condition);
+        if (!result[type].includes(conditionStringify)) {
+          result[type].push(conditionStringify);
+        }
+      });
+    };
+    respAppPopupData.forEach(popup => {
+      const conditionKeys = Object.keys(popup.conditions);
+      if (conditionKeys && conditionKeys.length) {
+        conditionKeys.forEach(con => getConditionByType(popup.conditions, con));
+      }
+    });
+    return result;
+  }
+  filterCampaignFunc(item, conditionMap) {
+    const isPassValidation = [];
+    if (Object.values(item.conditions) && Object.values(item.conditions).length) {
+      const conditionBalance = Object.values(item.conditions[MktCampaignConditionTypeValue.BALANCE] || {});
+      const conditionEarning = Object.values(item.conditions[MktCampaignConditionTypeValue.EARNING] || {});
+      const conditionNft = Object.values(item.conditions[MktCampaignConditionTypeValue.NFT] || {});
+      const conditionCrowdloan = Object.values(item.conditions[MktCampaignConditionTypeValue.CROWDLOAN] || {});
+      const conditionHasMoney = Object.values(item.conditions[MktCampaignConditionTypeValue.HAS_MONEY] || {});
+      if (conditionBalance && conditionBalance.length) {
+        const isValidArr = conditionBalance.map(condition => {
+          return conditionMap[JSON.stringify(condition)];
+        });
+        isPassValidation.push(isValidArr.some(i => i));
+      }
+      if (conditionEarning && conditionEarning.length) {
+        const isValidArr = conditionEarning.map(condition => {
+          return conditionMap[JSON.stringify(condition)];
+        });
+        isPassValidation.push(isValidArr.some(i => i));
+      }
+      if (conditionNft && conditionNft.length) {
+        const isValidArr = conditionNft.map(condition => {
+          return conditionMap[JSON.stringify(condition)];
+        });
+        isPassValidation.push(isValidArr.some(i => i));
+      }
+      if (conditionCrowdloan && conditionCrowdloan.length) {
+        const isValidArr = conditionCrowdloan.map(condition => {
+          return conditionMap[JSON.stringify(condition)];
+        });
+        isPassValidation.push(isValidArr.some(i => i));
+      }
+      if (conditionHasMoney && conditionHasMoney.length) {
+        const isValidArr = conditionHasMoney.map(condition => {
+          return conditionMap[JSON.stringify(condition)];
+        });
+        isPassValidation.push(isValidArr.some(i => i));
+      }
+    }
+    if (isPassValidation && isPassValidation.length) {
+      return isPassValidation.some(_i => _i);
+    } else {
+      return true;
+    }
+  }
+}

package/services/mkt-campaign-service/types.d.ts

@@ -0,0 +1,107 @@
+export declare type PopupFrequency = 'once' | 'daily' | 'weekly' | 'monthly' | 'every_time' | null;
+export declare type OnlineContentDataType = 'popup' | 'banner' | 'confirmation';
+export interface PopupHistoryData {
+    lastShowTime: number;
+    showTimes: number;
+}
+export interface AppBasicInfoData {
+    id: number;
+    name: string;
+    description: string | null;
+    start_time: string;
+    stop_time: string;
+    platforms: string[];
+    os: 'android' | 'ios';
+    is_changelog_popup?: boolean;
+}
+export interface AppContentButtonInstruction {
+    id: number;
+    confirm_label: string;
+    cancel_label: string;
+    instruction_id: number;
+    group: string;
+    slug: string;
+}
+export interface AppContentButtonAction {
+    id: number;
+    url: string;
+    screen: string;
+    params: string | null;
+    is_cancel: boolean;
+}
+export interface AppContentButton {
+    id: number;
+    label: string;
+    color: 'primary' | 'secondary' | 'warning' | 'danger' | 'ghost';
+    instruction: AppContentButtonInstruction | null;
+    action: AppContentButtonAction | null;
+}
+export declare type ComparisonMethod = 'eq' | 'gt' | 'gte' | 'lt' | 'lte';
+export declare type ConditionBalanceType = {
+    comparison: ComparisonMethod;
+    value: number;
+    chain_asset: string;
+};
+export declare type ConditionEarningType = {
+    comparison: ComparisonMethod;
+    value: number;
+    pool_slug: string;
+};
+export declare type ConditionNftType = {
+    chain: string;
+    collection_id: string;
+};
+export declare type ConditionCrowdloanType = {
+    chain: string;
+};
+export declare type ConditionHasMoneyType = {
+    has_money: string[];
+};
+export declare type ConditionType = 'condition-balance' | 'condition-earning' | 'condition-nft' | 'condition-crowdloan' | 'condition-has-money';
+export declare enum MktCampaignConditionTypeValue {
+    BALANCE = "condition-balance",
+    EARNING = "condition-earning",
+    NFT = "condition-nft",
+    CROWDLOAN = "condition-crowdloan",
+    HAS_MONEY = "condition-has-money"
+}
+export interface MktCampaignCondition {
+    [MktCampaignConditionTypeValue.BALANCE]: ConditionBalanceType[];
+    [MktCampaignConditionTypeValue.EARNING]: ConditionEarningType[];
+    [MktCampaignConditionTypeValue.NFT]: ConditionNftType[];
+    [MktCampaignConditionTypeValue.CROWDLOAN]: ConditionCrowdloanType[];
+    [MktCampaignConditionTypeValue.HAS_MONEY]: ConditionHasMoneyType[];
+}
+export interface PositionParam {
+    property: string;
+    value: string;
+}
+export interface AppCommonData {
+    id: number;
+    position: string;
+    position_params: PositionParam[];
+    conditions: MktCampaignCondition;
+    info?: AppBasicInfoData;
+}
+export interface AppPopupData extends AppCommonData {
+    priority: number;
+    repeat: PopupFrequency;
+    content: string;
+    media: string;
+    buttons: AppContentButton[];
+    repeat_every_x_days: number | null;
+}
+export interface AppBannerData extends AppCommonData {
+    priority: number;
+    media: string;
+    action: AppContentButtonAction;
+    instruction: AppContentButtonInstruction | null;
+}
+export interface AppConfirmationData extends AppCommonData {
+    name: string;
+    repeat: PopupFrequency;
+    confirm_label: string;
+    cancel_label: string;
+    content: string;
+    repeat_every_x_days: number | null;
+}

package/services/mkt-campaign-service/types.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let MktCampaignConditionTypeValue;
+(function (MktCampaignConditionTypeValue) {
+  MktCampaignConditionTypeValue["BALANCE"] = "condition-balance";
+  MktCampaignConditionTypeValue["EARNING"] = "condition-earning";
+  MktCampaignConditionTypeValue["NFT"] = "condition-nft";
+  MktCampaignConditionTypeValue["CROWDLOAN"] = "condition-crowdloan";
+  MktCampaignConditionTypeValue["HAS_MONEY"] = "condition-has-money";
+})(MktCampaignConditionTypeValue || (MktCampaignConditionTypeValue = {}));

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

@@ -44,6 +44,11 @@ export default class DatabaseService {
     updatePriceStore(priceData: PriceJson): Promise<void>;
     getPriceStore(keyData?: string): Promise<PriceJson | undefined>;
     getStoredBalance(): Promise<IBalance[]>;
+    checkBalanceByTokens(tokens: string[], comparison: 'eq' | 'gt' | 'gte' | 'lt' | 'lte', addresses: string[], amount: string): Promise<number>;
+    checkEarningByTokens(slug: string, comparison: 'eq' | 'gt' | 'gte' | 'lt' | 'lte', addresses: string[], amount: string): Promise<number>;
+    checkNftByTokens(chain: string, addresses: string[], collectionId?: string): Promise<number>;
+    checkCrowdloanByChain(chain: string, addresses: string[]): Promise<number>;
+    checkHasMoneyByTokens(types: string[], addresses: string[]): Promise<number>;
     updateBalanceStore(item: BalanceItem): Promise<unknown>;
     updateBulkBalanceStore(items: BalanceItem[]): Promise<unknown>;
     removeFromBalanceStore(assets: string[]): Promise<number>;

package/services/storage-service/DatabaseService.js

@@ -10,8 +10,9 @@ import MantaPayStore from '@subwallet/extension-base/services/storage-service/db
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import YieldPoolStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPoolStore';
 import YieldPositionStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPositionStore';
-import { reformatAddress } from '@subwallet/extension-base/utils';
+import { BN_ZERO, reformatAddress } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
 import { exportDB } from 'dexie-export-import';
 import { logger as createLogger } from '@polkadot/util';
 export const DEXIE_BACKUP_TABLES = ['chain', 'asset', 'migrations', 'transactions', 'campaign'];
@@ -70,6 +71,120 @@ export default class DatabaseService {
     // Filter not exist address
     return this.stores.balance.table.filter(obj => addresses.includes(obj.address)).toArray();
   }
+  async checkBalanceByTokens(tokens, comparison, addresses, amount) {
+    const filterFunc = item => {
+      const freeBalance = item === null || item === void 0 ? void 0 : item.free;
+      const lockedBalance = item === null || item === void 0 ? void 0 : item.locked;
+      const value = new BigN(freeBalance).plus(lockedBalance);
+      if (!addresses.includes(item.address)) {
+        return false;
+      }
+      switch (comparison) {
+        case 'eq':
+          return value.eq(amount || 0);
+        case 'gt':
+          return value.gt(amount || 0);
+        case 'gte':
+          return value.gte(amount || 0);
+        case 'lt':
+          return value.lt(amount || 0);
+        case 'lte':
+          return value.lte(amount || 0);
+      }
+    };
+    return this.stores.balance.checkBalanceByTokens(tokens, filterFunc);
+  }
+  async checkEarningByTokens(slug, comparison, addresses, amount) {
+    const filterFunc = item => {
+      if (!addresses.includes(item.address)) {
+        return false;
+      }
+      const value = new BigN(item.activeStake);
+      switch (comparison) {
+        case 'eq':
+          return value.eq(amount || 0);
+        case 'gt':
+          return value.gt(amount || 0);
+        case 'gte':
+          return value.gte(amount || 0);
+        case 'lt':
+          return value.lt(amount || 0);
+        case 'lte':
+          return value.lte(amount || 0);
+      }
+    };
+    return this.stores.yieldPosition.checkPositionByPoolSlug(slug, filterFunc);
+  }
+  async checkNftByTokens(chain, addresses, collectionId) {
+    const filterFunc = item => {
+      if (!addresses.includes(item.address)) {
+        return false;
+      } else {
+        return true;
+      }
+    };
+    return this.stores.nft.checkNftsByChainAndCollection(chain, filterFunc, collectionId);
+  }
+  async checkCrowdloanByChain(chain, addresses) {
+    const filterFunc = item => {
+      if (!addresses.includes(item.address)) {
+        return false;
+      } else {
+        return true;
+      }
+    };
+    return this.stores.crowdloan.checkCrowdloanExist(filterFunc);
+  }
+  async checkHasMoneyByTokens(types, addresses) {
+    const allHasMoneysConditionValid = [];
+    if (types.includes('balance')) {
+      const filterFunc = item => {
+        if (!addresses.includes(item.address)) {
+          return false;
+        }
+        const freeBalance = item === null || item === void 0 ? void 0 : item.free;
+        const lockedBalance = item === null || item === void 0 ? void 0 : item.locked;
+        const value = new BigN(freeBalance).plus(lockedBalance);
+        return value.gt(BN_ZERO);
+      };
+      const balanceResult = await this.stores.balance.checkBalanceExist(filterFunc);
+      balanceResult > 0 && allHasMoneysConditionValid.push('balance');
+    }
+    if (types.includes('earning')) {
+      const filterFunc = item => {
+        if (!addresses.includes(item.address)) {
+          return false;
+        }
+        const value = new BigN(item.activeStake);
+        return value.gt(BN_ZERO);
+      };
+      const earningResult = await this.stores.yieldPosition.checkPositionExist(filterFunc);
+      earningResult > 0 && allHasMoneysConditionValid.push('earning');
+    }
+    if (types.includes('nft')) {
+      const filterFunc = item => {
+        if (!addresses.includes(item.address)) {
+          return false;
+        } else {
+          return true;
+        }
+      };
+      const nftResult = await this.stores.nft.checkNftExist(filterFunc);
+      nftResult > 0 && allHasMoneysConditionValid.push('nft');
+    }
+    if (types.includes('crowdloan')) {
+      const filterFunc = item => {
+        if (!addresses.includes(item.address)) {
+          return false;
+        } else {
+          return true;
+        }
+      };
+      const crowdloanResult = await this.stores.crowdloan.checkCrowdloanExist(filterFunc);
+      crowdloanResult > 0 && allHasMoneysConditionValid.push('crowdloan');
+    }
+    return allHasMoneysConditionValid.length;
+  }
   async updateBalanceStore(item) {
     if (item.state === APIItemState.READY) {
       return this.stores.balance.upsert({

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

@@ -5,4 +5,6 @@ export default class BalanceStore extends BaseStoreWithAddress<IBalance> {
     getBalanceMapByAddresses(addresses: string): Promise<BalanceItem[]>;
     removeBySlugs(tokenSlugs: string[]): Promise<number>;
     removeByAddresses(addresses: string[]): Promise<number>;
+    checkBalanceByTokens(tokens: string[], filterFunc: (i: IBalance) => boolean): Promise<number>;
+    checkBalanceExist(filterFunc: (x: IBalance) => boolean): Promise<number>;
 }

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

@@ -12,4 +12,10 @@ export default class BalanceStore extends BaseStoreWithAddress {
   async removeByAddresses(addresses) {
     return this.table.where('address').anyOfIgnoreCase(addresses).delete();
   }
+  async checkBalanceByTokens(tokens, filterFunc) {
+    return this.table.where('tokenSlug').anyOfIgnoreCase(tokens).filter(filterFunc).count();
+  }
+  async checkBalanceExist(filterFunc) {
+    return this.table.filter(item => filterFunc(item)).count();
+  }
 }

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

@@ -4,4 +4,6 @@ export default class CrowdloanStore extends BaseStoreWithAddressAndChain<ICrowdl
     removeEndedCrowdloans(): Promise<void>;
     getCrowdloan(address: string): import("dexie").PromiseExtended<ICrowdloanItem[]>;
     deleteByChainAndAddress(chain: string, address: string): import("dexie").PromiseExtended<number>;
+    checkCrowdloanByChain(chain: string, filterFunc: (i: ICrowdloanItem) => boolean): import("dexie").PromiseExtended<number>;
+    checkCrowdloanExist(filterFunc: (i: ICrowdloanItem) => boolean): import("dexie").PromiseExtended<number>;
 }

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

@@ -26,4 +26,12 @@ export default class CrowdloanStore extends BaseStoreWithAddressAndChain {
       address
     }).delete();
   }
+  checkCrowdloanByChain(chain, filterFunc) {
+    return this.table.where({
+      chain
+    }).filter(filterFunc).count();
+  }
+  checkCrowdloanExist(filterFunc) {
+    return this.table.filter(filterFunc).count();
+  }
 }

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

@@ -11,4 +11,6 @@ export default class NftStore extends BaseStoreWithAddressAndChain<INft> {
     deleteNftsByCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;
     removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
     removeNftsByAddress(addresses: string[]): import("dexie").PromiseExtended<number>;
+    checkNftsByChainAndCollection(chain: string, filterFunc: (x: INft) => boolean, collectionId?: string): import("dexie").PromiseExtended<number>;
+    checkNftExist(filterFunc: (x: INft) => boolean): import("dexie").PromiseExtended<number>;
 }

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

@@ -49,6 +49,18 @@ export default class NftStore extends BaseStoreWithAddressAndChain {
   removeNftsByAddress(addresses) {
     return this.table.where('address').anyOfIgnoreCase(addresses).delete();
   }
+  checkNftsByChainAndCollection(chain, filterFunc, collectionId) {
+    const data = collectionId ? this.table.where({
+      chain,
+      collectionId
+    }) : this.table.where({
+      chain
+    });
+    return data.filter(item => filterFunc(item)).count();
+  }
+  checkNftExist(filterFunc) {
+    return this.table.filter(filterFunc).count();
+  }
 
   // reformatCollectionIds (items: INft[]) {
   //   return items.map((item) => {

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

@@ -4,4 +4,5 @@ export default class NftCollectionStore extends BaseStoreWithChain<NftCollection
     subscribeNftCollection(getChains: () => string[] | undefined): import("dexie").Observable<NftCollection[]>;
     getNftCollection(chainList?: string[]): import("dexie").PromiseExtended<NftCollection[]>;
     removeCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;
+    checkNftByChainOrCollectionId(chain: string, collectionId?: string): Promise<number>;
 }

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

@@ -19,4 +19,15 @@ export default class NftCollectionStore extends BaseStoreWithChain {
       collectionId
     }).delete();
   }
+  async checkNftByChainOrCollectionId(chain, collectionId) {
+    if (collectionId) {
+      return this.table.where({
+        chain,
+        collectionId
+      }).count();
+    }
+    return this.table.where({
+      chain
+    }).count();
+  }
 }

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

@@ -8,4 +8,6 @@ export default class YieldPositionStore extends BaseStore<YieldPositionInfo> {
     getByAddressAndChains(addresses: string[], chains: string[]): Promise<YieldPositionInfo[]>;
     getByAddressAndSlug(address: string, slug: string): import("dexie").PromiseExtended<YieldPositionInfo | undefined>;
     subscribeYieldPositions(addresses: string[]): import("dexie").Observable<YieldPositionInfo[]>;
+    checkPositionByPoolSlug(slug: string, filterFunc: (i: YieldPositionInfo) => boolean): Promise<number>;
+    checkPositionExist(filterFunc: (i: YieldPositionInfo) => boolean): Promise<number>;
 }

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

@@ -60,4 +60,10 @@ export default class YieldPositionStore extends BaseStore {
   subscribeYieldPositions(addresses) {
     return liveQuery(() => this.getByAddress(addresses));
   }
+  async checkPositionByPoolSlug(slug, filterFunc) {
+    return this.table.where('slug').anyOfIgnoreCase(slug).filter(filterFunc).limit(1).count();
+  }
+  async checkPositionExist(filterFunc) {
+    return this.table.filter(filterFunc).limit(1).count();
+  }
 }

package/types/balance/index.d.ts

@@ -1,7 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _BalanceMetadata, APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
-import { ApiPromise } from '@polkadot/api';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BN } from '@polkadot/util';
 export interface TokenBalanceRaw {
     reserved: BN;
@@ -43,7 +42,7 @@ export interface SubscribeBasePalletBalance {
     extrinsicType?: ExtrinsicType;
 }
 export interface SubscribeSubstratePalletBalance extends SubscribeBasePalletBalance {
-    substrateApi: ApiPromise;
+    substrateApi: _SubstrateApi;
     includeNativeToken?: boolean;
 }
 export interface SubscribeEvmPalletBalance extends SubscribeBasePalletBalance {