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

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

@@ -10,7 +10,6 @@ var _api2 = require("@gear-js/api");
 var _types = require("@oak-foundation/types");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _lightClient = require("@subwallet/extension-base/services/chain-service/handler/light-client");
-var _SubstrateChainHandler = require("@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler");
 var _types2 = require("@subwallet/extension-base/services/chain-service/types");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _availJsSdk = require("avail-js-sdk");
@@ -18,8 +17,6 @@ var _rxjs = require("rxjs");
 var _api3 = require("@polkadot/api");
 var _api4 = require("@polkadot/apps-config/api");
 var _create = require("@polkadot/types/create");
-var _util = require("@polkadot/util");
-var _defaults = require("@polkadot/util-crypto/address/defaults");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -62,6 +59,11 @@ class SubstrateApi {
       this.connectionStatusSubject.next(status);
     }
   }
+
+  // apiDefaultTx?: SubmittableExtrinsicFunction;
+  // apiDefaultTxSudo?: SubmittableExtrinsicFunction;
+  // defaultFormatBalance?: _SubstrateDefaultFormatBalance;
+
   specName = '';
   specVersion = '';
   systemChain = '';
@@ -231,44 +233,136 @@ class SubstrateApi {
     console.warn(`${this.chainSlug} connection got error`, e);
   }
   async fillApiInfo() {
-    var _api$rpc$system, _api$rpc$system2, _api$rpc$system3;
-    const {
-      api,
-      registry
-    } = this;
-    const DEFAULT_DECIMALS = registry.createType('u32', 12);
-    const DEFAULT_SS58 = registry.createType('u32', _defaults.defaults.prefix);
+    // const { registry } = this;
+    // const DEFAULT_DECIMALS = registry.createType('u32', 12);
+    // const DEFAULT_SS58 = registry.createType('u32', addressDefaults.prefix);
+
     this.specName = this.api.runtimeVersion.specName.toString();
     this.specVersion = this.api.runtimeVersion.specVersion.toString();
-    const [systemChain, systemName, systemVersion] = await Promise.all([(_api$rpc$system = api.rpc.system) === null || _api$rpc$system === void 0 ? void 0 : _api$rpc$system.chain(), (_api$rpc$system2 = api.rpc.system) === null || _api$rpc$system2 === void 0 ? void 0 : _api$rpc$system2.name(), (_api$rpc$system3 = api.rpc.system) === null || _api$rpc$system3 === void 0 ? void 0 : _api$rpc$system3.version()]);
+    const [systemChain, systemName, systemVersion] = await Promise.all([this.makeRpcQuery({
+      section: 'rpc',
+      module: 'system',
+      method: 'chain'
+    }), this.makeRpcQuery({
+      section: 'rpc',
+      module: 'system',
+      method: 'name'
+    }), this.makeRpcQuery({
+      section: 'rpc',
+      module: 'system',
+      method: 'version'
+    })]);
     this.systemChain = systemChain.toString();
     this.systemName = systemName.toString();
     this.systemVersion = systemVersion.toString();
-    const properties = registry.createType('ChainProperties', {
-      ss58Format: api.registry.chainSS58,
-      tokenDecimals: api.registry.chainDecimals,
-      tokenSymbol: api.registry.chainTokens
-    });
-    const ss58Format = properties.ss58Format.unwrapOr(DEFAULT_SS58).toNumber();
-    const tokenSymbol = properties.tokenSymbol.unwrapOr([_util.formatBalance.getDefaults().unit, ..._SubstrateChainHandler.DEFAULT_AUX]);
-    const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
-    registry.setChainProperties(registry.createType('ChainProperties', {
-      ss58Format,
-      tokenDecimals,
-      tokenSymbol
-    }));
+
+    // const [ss58Format, tokenDecimals, tokenSymbol] = await Promise.all([
+    //   this.makeRpcQuery<number | undefined>({ section: 'registry', module: 'chainSS58' }),
+    //   this.makeRpcQuery<number[]>({ section: 'registry', module: 'chainDecimals' }),
+    //   this.makeRpcQuery<string[]>({ section: 'registry', module: 'chainTokens' })
+    // ]);
+    //
+    // const properties = registry.createType('ChainProperties', {
+    //   ss58Format,
+    //   tokenDecimals,
+    //   tokenSymbol
+    // });
+    // const ss58Format = properties.ss58Format.unwrapOr(DEFAULT_SS58).toNumber();
+    // const tokenSymbol = properties.tokenSymbol.unwrapOr([formatBalance.getDefaults().unit, ...DEFAULT_AUX]);
+    // const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
+    //
+    // registry.setChainProperties(registry.createType('ChainProperties', { ss58Format, tokenDecimals, tokenSymbol }));
 
     // first set up the UI helpers
-    this.defaultFormatBalance = {
-      decimals: tokenDecimals.map(b => {
-        return b.toNumber();
-      }),
-      unit: tokenSymbol[0].toString()
-    };
-    const defaultSection = Object.keys(api.tx)[0];
-    const defaultMethod = Object.keys(api.tx[defaultSection])[0];
-    this.apiDefaultTx = api.tx[defaultSection][defaultMethod];
-    this.apiDefaultTxSudo = api.tx.system && api.tx.system.setCode || this.apiDefaultTx;
+    // this.defaultFormatBalance = {
+    //   decimals: tokenDecimals.map((b: BN) => {
+    //     return b.toNumber();
+    //   }),
+    //   unit: tokenSymbol[0].toString()
+    // };
+    //
+    // const defaultSection = Object.keys(api.tx)[0];
+    // const defaultMethod = Object.keys(api.tx[defaultSection])[0];
+
+    // this.apiDefaultTx = api.tx[defaultSection][defaultMethod];
+    // this.apiDefaultTxSudo = (api.tx.system && api.tx.system.setCode) || this.apiDefaultTx;
+  }
+
+  async makeRpcQuery(_ref) {
+    let {
+      args,
+      method,
+      module,
+      section
+    } = _ref;
+    const isGetterCall = section === 'genesisHash' || section === 'extrinsicVersion' || section === 'runtimeVersion' || section === 'runtimeMetadata' || section === 'registry';
+    const isRuntimeConstQuery = section === 'consts' && !!method && !!module && !args;
+    const isRpcQuery = section === 'rpc' && !!method && !!module && !args;
+    const isStateQuery = section === 'query' && method && module;
+    if (isGetterCall) {
+      if (section === 'genesisHash') {
+        return this.api[section].toHex();
+      } else if (section === 'extrinsicVersion') {
+        return this.api[section];
+      } else if (section === 'runtimeVersion') {
+        return this.api[section].toPrimitive();
+      } else if (section === 'runtimeMetadata') {
+        return this.api[section].toHex();
+      } else if (section === 'registry') {
+        return this.api[section];
+      }
+    }
+    if (isRuntimeConstQuery) {
+      if (!this.api[section][module]) {
+        return undefined;
+      }
+      return this.api[section][module][method].toPrimitive();
+    }
+    if (isRpcQuery) {
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      if (!this.api[section][module]) {
+        return undefined;
+      }
+
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      return (await this.api[section][module][method]()).toPrimitive(); // todo: improve this
+    }
+
+    if (isStateQuery) {
+      if (!this.api[section][module]) {
+        return undefined;
+      }
+      if (args) {
+        return (await this.api[section][module][method](...args)).toPrimitive();
+      } else {
+        return (await this.api[section][module][method]()).toPrimitive();
+      }
+    }
+    return Promise.reject(new Error('Cannot handle query'));
+  }
+  subscribeDataWithMulti(params, callback) {
+    const apiRx = this.api.rx;
+    const observables = {};
+    params.forEach(queryParams => {
+      const {
+        args,
+        method,
+        module,
+        section
+      } = queryParams;
+      const key = `${section}_${module}_${method}`;
+      if (!this.api[section][module] || !this.api[section][module][method]) {
+        // if method not found, returns an empty observable
+        observables[key] = new _rxjs.Observable(subscriber => {
+          subscriber.next([]);
+        });
+      } else {
+        observables[key] = apiRx[section][module][method].multi(args).pipe((0, _rxjs.map)(codecs => codecs.map(codec => codec.toPrimitive())));
+      }
+    });
+    return (0, _rxjs.combineLatest)(observables).subscribe(callback);
   }
 }
 exports.SubstrateApi = SubstrateApi;

package/cjs/services/chain-service/handler/SubstrateChainHandler.js

@@ -69,12 +69,13 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
     }
   }
   async getChainSpec(substrateApi) {
-    var _substrateApi$api$gen, _substrateApi$api, _substrateApi$api$con, _substrateApi$api$con2, _substrateApi$api$con3;
     const result = {
       addressPrefix: -1,
       decimals: 0,
       existentialDeposit: '',
-      genesisHash: (_substrateApi$api$gen = substrateApi.api.genesisHash) === null || _substrateApi$api$gen === void 0 ? void 0 : _substrateApi$api$gen.toHex(),
+      genesisHash: await substrateApi.makeRpcQuery({
+        section: 'genesisHash'
+      }),
       name: '',
       symbol: '',
       paraId: null
@@ -82,17 +83,33 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
     const {
       chainDecimals,
       chainTokens
-    } = substrateApi.api.registry;
-    if (substrateApi.api.query.parachainInfo) {
-      result.paraId = (await substrateApi.api.query.parachainInfo.parachainId()).toPrimitive();
-    }
+    } = await substrateApi.makeRpcQuery({
+      section: 'registry'
+    });
+    result.paraId = await substrateApi.makeRpcQuery({
+      section: 'query',
+      module: 'parachainInfo',
+      method: 'parachainId'
+    });
 
     // get first token by default, might change
-    result.name = (await substrateApi.api.rpc.system.chain()).toPrimitive();
+    result.name = await substrateApi.makeRpcQuery({
+      section: 'rpc',
+      module: 'system',
+      method: 'chain'
+    });
     result.symbol = chainTokens[0];
     result.decimals = chainDecimals[0];
-    result.addressPrefix = (_substrateApi$api = substrateApi.api) === null || _substrateApi$api === void 0 ? void 0 : (_substrateApi$api$con = _substrateApi$api.consts) === null || _substrateApi$api$con === void 0 ? void 0 : (_substrateApi$api$con2 = _substrateApi$api$con.system) === null || _substrateApi$api$con2 === void 0 ? void 0 : (_substrateApi$api$con3 = _substrateApi$api$con2.ss58Prefix) === null || _substrateApi$api$con3 === void 0 ? void 0 : _substrateApi$api$con3.toPrimitive();
-    result.existentialDeposit = substrateApi.api.consts.balances.existentialDeposit.toString();
+    result.addressPrefix = await substrateApi.makeRpcQuery({
+      section: 'consts',
+      module: 'system',
+      method: 'ss58Prefix'
+    });
+    result.existentialDeposit = await substrateApi.makeRpcQuery({
+      section: 'consts',
+      module: 'balances',
+      method: 'existentialDeposit'
+    });
     return result;
   }
   async getPsp22TokenInfo(apiPromise, contractAddress, contractCaller) {

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

@@ -81,6 +81,7 @@ var _exportNames = {
   findChainInfoByChainId: true,
   _isMantaZkAsset: true,
   _getChainExistentialDeposit: true,
+  _getAssetExistentialDeposit: true,
   randomizeProvider: true,
   _isAssetCanPayTxFee: true,
   updateLatestChainInfo: true
@@ -88,6 +89,7 @@ var _exportNames = {
 exports._checkSmartContractSupportByChain = _checkSmartContractSupportByChain;
 exports._generateCustomProviderKey = _generateCustomProviderKey;
 exports._getAssetDecimals = _getAssetDecimals;
+exports._getAssetExistentialDeposit = _getAssetExistentialDeposit;
 exports._getAssetName = _getAssetName;
 exports._getAssetOriginChain = _getAssetOriginChain;
 exports._getAssetPriceId = _getAssetPriceId;
@@ -599,6 +601,9 @@ function _getChainExistentialDeposit(chainInfo) {
   var _chainInfo$substrateI20;
   return (chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI20 = chainInfo.substrateInfo) === null || _chainInfo$substrateI20 === void 0 ? void 0 : _chainInfo$substrateI20.existentialDeposit) || '0';
 }
+function _getAssetExistentialDeposit(chainAsset) {
+  return (chainAsset === null || chainAsset === void 0 ? void 0 : chainAsset.minAmount) || '0';
+}
 function randomizeProvider(providers, excludedKeys) {
   if (Object.keys(providers).length === 0) {
     return {

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

@@ -19,7 +19,7 @@ class MigrateLedgerAccountV2 extends _Base.default {
         const store = new _stores.AccountsStore();
         const update = (key, value) => {
           var _value$meta;
-          if (key.startsWith('account:') && value.meta && (0, _util.isString)((_value$meta = value.meta) === null || _value$meta === void 0 ? void 0 : _value$meta.originGenesisHash)) {
+          if (key.startsWith('account:') && value.meta && (0, _util.isString)((_value$meta = value.meta) === null || _value$meta === void 0 ? void 0 : _value$meta.genesisHash)) {
             const newValue = {
               ...value
             };
@@ -28,10 +28,10 @@ class MigrateLedgerAccountV2 extends _Base.default {
               if (isEther) {
                 newValue.meta.isGeneric = true;
               } else {
-                newValue.meta.isGeneric = !newValue.meta.originGenesisHash;
+                newValue.meta.isGeneric = !newValue.meta.genesisHash;
               }
             }
-            newValue.meta.availableGenesisHashes = [value.meta.originGenesisHash];
+            newValue.meta.availableGenesisHashes = [value.meta.genesisHash];
             store.set(key, newValue);
           }
         };

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

@@ -0,0 +1,284 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/services/mkt-campaign-service/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MktCampaignService {
+  #state;
+  appPopupSubject = new _rxjs.BehaviorSubject([]);
+  appBannerSubject = new _rxjs.BehaviorSubject([]);
+  appConfirmationSubject = new _rxjs.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() {
+    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10000;
+    (0, _utils2.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 (0, _utils2.fetchStaticData)('app-popups');
+    const result = await this.handleMktCampaignData(respAppPopupData);
+    this.appPopupSubject.next(result);
+  }
+  async fetchBannerData() {
+    const respAppBannerData = await (0, _utils2.fetchStaticData)('app-banners');
+    const result = await this.handleMktCampaignData(respAppBannerData);
+    this.appBannerSubject.next(result);
+  }
+  async fetchConfirmationData() {
+    const respAppConfirmationData = await (0, _utils2.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 = _uiKeyring.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(_utils2.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[_types.MktCampaignConditionTypeValue.BALANCE]) === null || _allConditions$MktCam === void 0 ? void 0 : _allConditions$MktCam.map(condition => {
+      return JSON.parse(condition);
+    });
+    const allBalanceConditionPromises = [];
+    allBalanceConditions.forEach(balanceCondition => {
+      const decimals = (0, _utils._getAssetDecimals)(this.#state.getAssetBySlug(balanceCondition.chain_asset));
+      const convertedValue = new _bignumber.default(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[_types.MktCampaignConditionTypeValue.BALANCE][i]] = rs > 0;
+    });
+    return conditionBalanceMap;
+  }
+  async checkEarningCondition(allConditions, addresses) {
+    var _allConditions$MktCam2;
+    const allEarningConditions = (_allConditions$MktCam2 = allConditions[_types.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
+      } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+      const convertedValue = new _bignumber.default(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[_types.MktCampaignConditionTypeValue.EARNING][i]] = rs > 0;
+    });
+    return conditionEarningMap;
+  }
+  async checkNftCondition(allConditions, addresses) {
+    var _allConditions$MktCam3;
+    const allNftConditions = (_allConditions$MktCam3 = allConditions[_types.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[_types.MktCampaignConditionTypeValue.NFT][i]] = rs > 0;
+    });
+    return conditionNftMap;
+  }
+  async checkCrowdloanCondition(allConditions, addresses) {
+    var _allConditions$MktCam4;
+    const allCrowdloanConditions = (_allConditions$MktCam4 = allConditions[_types.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[_types.MktCampaignConditionTypeValue.CROWDLOAN][i]] = rs > 0;
+    });
+    return conditionCrowdloanMap;
+  }
+  async checkHasMoneyCondition(allConditions, addresses) {
+    const hasMoneyCondition = allConditions[_types.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 = {
+      [_types.MktCampaignConditionTypeValue.BALANCE]: [],
+      [_types.MktCampaignConditionTypeValue.EARNING]: [],
+      [_types.MktCampaignConditionTypeValue.CROWDLOAN]: [],
+      [_types.MktCampaignConditionTypeValue.NFT]: [],
+      [_types.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[_types.MktCampaignConditionTypeValue.BALANCE] || {});
+      const conditionEarning = Object.values(item.conditions[_types.MktCampaignConditionTypeValue.EARNING] || {});
+      const conditionNft = Object.values(item.conditions[_types.MktCampaignConditionTypeValue.NFT] || {});
+      const conditionCrowdloan = Object.values(item.conditions[_types.MktCampaignConditionTypeValue.CROWDLOAN] || {});
+      const conditionHasMoney = Object.values(item.conditions[_types.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;
+    }
+  }
+}
+exports.default = MktCampaignService;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MktCampaignConditionTypeValue = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let MktCampaignConditionTypeValue;
+exports.MktCampaignConditionTypeValue = 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 || (exports.MktCampaignConditionTypeValue = MktCampaignConditionTypeValue = {}));