@subwallet/extension-base 1.1.32-0 → 1.1.33-0

package/background/KoniTypes.d.ts

@@ -392,6 +392,7 @@ export declare enum ExtrinsicStatus {
     SUCCESS = "success",
     FAIL = "fail",
     CANCELLED = "cancelled",
+    TIMEOUT = "timeout",
     UNKNOWN = "unknown"
 }
 export interface TxHistoryItem {
@@ -1553,6 +1554,7 @@ export interface BaseCampaignData {
     slug: string;
     campaignId: number;
     isDone: boolean;
+    isArchive: boolean;
     type: CampaignDataType;
     data: Record<string, any>;
     buttons: CampaignButton[];

package/background/KoniTypes.js

@@ -85,6 +85,7 @@ export let ExtrinsicStatus;
   ExtrinsicStatus["SUCCESS"] = "success";
   ExtrinsicStatus["FAIL"] = "fail";
   ExtrinsicStatus["CANCELLED"] = "cancelled";
+  ExtrinsicStatus["TIMEOUT"] = "timeout";
   ExtrinsicStatus["UNKNOWN"] = "unknown";
 })(ExtrinsicStatus || (ExtrinsicStatus = {}));
 export let BasicTxErrorType;

package/cjs/background/KoniTypes.js

@@ -100,6 +100,7 @@ exports.ExtrinsicStatus = ExtrinsicStatus;
   ExtrinsicStatus["SUCCESS"] = "success";
   ExtrinsicStatus["FAIL"] = "fail";
   ExtrinsicStatus["CANCELLED"] = "cancelled";
+  ExtrinsicStatus["TIMEOUT"] = "timeout";
   ExtrinsicStatus["UNKNOWN"] = "unknown";
 })(ExtrinsicStatus || (exports.ExtrinsicStatus = ExtrinsicStatus = {}));
 let BasicTxErrorType;

package/cjs/koni/api/staking/bonding/amplitude.js

@@ -30,7 +30,7 @@ function subscribeAmplitudeStakingMetadata(chain, substrateApi, callback) {
     const unstakingDelay = substrateApi.api.consts.parachainStaking.stakeDuration.toString();
     const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
     const blockPerRound = parseFloat(_blockPerRound);
-    const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+    const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound;
     const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
     callback(chain, {
       chain,
@@ -72,46 +72,52 @@ async function subscribeAmplitudeNominatorMetadata(chainInfo, address, substrate
   const nominationList = [];
   const unstakingList = [];
   const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+  const hasUnstakingInfo = unstakingInfo && Object.values(unstakingInfo).length > 0;
   let activeStake = '0';
   if (delegatorState) {
     // delegatorState can be null while unstaking all
-    const [identity] = await (0, _utils.parseIdentity)(substrateApi, delegatorState.owner);
-    activeStake = delegatorState.amount.toString();
-    const bnActiveStake = new _util.BN(activeStake);
-    let delegationStatus = _KoniTypes.StakingStatus.NOT_EARNING;
-    if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegatorStake))) {
-      delegationStatus = _KoniTypes.StakingStatus.EARNING_REWARD;
-    }
-    nominationList.push({
-      status: delegationStatus,
-      chain: chainInfo.slug,
-      validatorAddress: delegatorState.owner,
-      activeStake: delegatorState.amount.toString(),
-      validatorMinStake: '0',
-      hasUnstaking: !!unstakingInfo && Object.values(unstakingInfo).length > 0,
-      validatorIdentity: identity
-    });
-  }
-  if (unstakingInfo && Object.values(unstakingInfo).length > 0) {
-    const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
-    const currentBlockInfo = _currentBlockInfo.toPrimitive();
-    const currentBlockNumber = currentBlockInfo.number;
-    const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
-    const blockPerRound = parseFloat(_blockPerRound);
-    const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
-    const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
-    const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+    const identityPromises = delegatorState.map(delegate => (0, _utils.parseIdentity)(substrateApi, delegate.owner));
+    const identities = await Promise.all(identityPromises);
+    for (let i = 0; i < delegatorState.length; i++) {
+      const delegate = delegatorState[i];
+      const [identity] = identities[i];
+      activeStake = delegate.amount.toString();
+      const bnActiveStake = new _util.BN(activeStake);
+      let delegationStatus = _KoniTypes.StakingStatus.NOT_EARNING;
+      if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegatorStake))) {
+        delegationStatus = _KoniTypes.StakingStatus.EARNING_REWARD;
+      }
+      nominationList.push({
+        status: delegationStatus,
+        chain: chainInfo.slug,
+        validatorAddress: delegate.owner,
+        activeStake: delegate.amount.toString(),
+        validatorMinStake: '0',
+        hasUnstaking: hasUnstakingInfo,
+        validatorIdentity: identity
+      });
+      if (hasUnstakingInfo) {
+        const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
+        const currentBlockInfo = _currentBlockInfo.toPrimitive();
+        const currentBlockNumber = currentBlockInfo.number;
+        const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+        const blockPerRound = parseFloat(_blockPerRound);
+        const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
+        const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
+        const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
 
-    const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber < 0;
-    const remainingBlock = parseInt(nearestUnstakingBlock) - currentBlockNumber;
-    const waitingTime = remainingBlock * blockDuration;
-    unstakingList.push({
-      chain: chainInfo.slug,
-      status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
-      claimable: nearestUnstakingAmount.toString(),
-      waitingTime,
-      validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
-    });
+        const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber < 0;
+        const remainingBlock = parseInt(nearestUnstakingBlock) - currentBlockNumber;
+        const waitingTime = remainingBlock * blockDuration;
+        unstakingList.push({
+          chain: chainInfo.slug,
+          status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+          claimable: nearestUnstakingAmount.toString(),
+          waitingTime,
+          validatorAddress: (delegate === null || delegate === void 0 ? void 0 : delegate.owner) || undefined
+        });
+      }
+    }
   }
   const stakingStatus = (0, _utils.getStakingStatusByNominations)(new _util.BN(activeStake), nominationList);
   return {
@@ -208,33 +214,61 @@ async function getAmplitudeNominatorMetadata(chainInfo, address, substrateApi) {
 }
 async function getAmplitudeCollatorsInfo(chain, substrateApi) {
   const chainApi = await substrateApi.isReady;
-  const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
-  const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
-  const inflationConfig = _inflationConfig.toHuman();
-  const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
-  const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
-  const allCollators = [];
-  for (const _collator of _allCollators) {
-    const collatorInfo = _collator[1].toPrimitive();
-    const bnTotalStake = new _util.BN(collatorInfo.total);
-    const bnOwnStake = new _util.BN(collatorInfo.stake);
-    const bnOtherStake = bnTotalStake.sub(bnOwnStake);
-    allCollators.push({
-      address: collatorInfo.id,
-      totalStake: bnTotalStake.toString(),
-      ownStake: bnOwnStake.toString(),
-      otherStake: bnOtherStake.toString(),
-      nominatorCount: collatorInfo.delegators.length,
-      commission: 0,
-      expectedReturn: delegatorReturn,
-      blocked: false,
-      isVerified: false,
-      minBond: '0',
-      chain,
-      isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
-    });
+
+  // Noted: Krest do not have reward
+  if (_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
+    const _allCollators = await chainApi.api.query.parachainStaking.candidatePool.entries();
+    const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+    const allCollators = [];
+    for (const _collator of _allCollators) {
+      const collatorInfo = _collator[1].toPrimitive();
+      const bnTotalStake = new _util.BN(collatorInfo.total);
+      const bnOwnStake = new _util.BN(collatorInfo.stake);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      allCollators.push({
+        address: collatorInfo.id,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: bnOtherStake.toString(),
+        nominatorCount: collatorInfo.delegators.length,
+        commission: 0,
+        blocked: false,
+        isVerified: false,
+        minBond: '0',
+        chain,
+        isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+      });
+    }
+    return allCollators;
+  } else {
+    const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
+    const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+    const inflationConfig = _inflationConfig.toHuman();
+    const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
+    const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
+    const allCollators = [];
+    for (const _collator of _allCollators) {
+      const collatorInfo = _collator[1].toPrimitive();
+      const bnTotalStake = new _util.BN(collatorInfo.total);
+      const bnOwnStake = new _util.BN(collatorInfo.stake);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      allCollators.push({
+        address: collatorInfo.id,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: bnOtherStake.toString(),
+        nominatorCount: collatorInfo.delegators.length,
+        commission: 0,
+        expectedReturn: delegatorReturn,
+        blocked: false,
+        isVerified: false,
+        minBond: '0',
+        chain,
+        isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+      });
+    }
+    return allCollators;
   }
-  return allCollators;
 }
 async function getAmplitudeBondingExtrinsic(substrateApi, amount, selectedValidatorInfo, nominatorMetadata) {
   const chainApi = await substrateApi.isReady;

package/cjs/koni/api/staking/paraChain.js

@@ -22,7 +22,15 @@ var _utilCrypto = require("@polkadot/util-crypto");
 function getSingleStakingAmplitude(substrateApi, address, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
   return substrateApi.api.queryMulti([[substrateApi.api.query.parachainStaking.delegatorState, address], [substrateApi.api.query.parachainStaking.unstaking, address]], async _ref => {
     let [_delegatorState, _unstaking] = _ref;
-    const delegatorState = _delegatorState.toPrimitive();
+    let delegatorState = [];
+    if (_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
+      const krestDelegatorState = _delegatorState.toPrimitive();
+      const delegates = krestDelegatorState === null || krestDelegatorState === void 0 ? void 0 : krestDelegatorState.delegations;
+      delegatorState = delegatorState.concat(delegates);
+    } else {
+      const delegate = _delegatorState.toPrimitive();
+      delegatorState.push(delegate);
+    }
     const unstakingInfo = _unstaking.toPrimitive();
     const {
       symbol
@@ -51,8 +59,13 @@ function getSingleStakingAmplitude(substrateApi, address, chainInfoMap, chain, s
         unstakings: []
       });
     } else {
-      const activeBalance = delegatorState ? new _util.BN(delegatorState.amount.toString()) : _util.BN_ZERO;
+      let activeBalance = _util.BN_ZERO;
       let unstakingBalance = _util.BN_ZERO;
+      for (const delegate of delegatorState) {
+        var _delegate$amount;
+        const amount = new _util.BN((_delegate$amount = delegate.amount) === null || _delegate$amount === void 0 ? void 0 : _delegate$amount.toString());
+        activeBalance = activeBalance.add(amount);
+      }
       if (unstakingInfo) {
         Object.values(unstakingInfo).forEach(unstakingAmount => {
           const bnUnstakingAmount = new _util.BN(unstakingAmount.toString());
@@ -87,7 +100,15 @@ function getMultiStakingAmplitude(substrateApi, useAddresses, chainInfoMap, chai
       const _unstakingStates = await substrateApi.api.query.parachainStaking.unstaking.multi(useAddresses);
       await Promise.all(ledgers.map(async (_delegatorState, i) => {
         const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
-        const delegatorState = _delegatorState.toPrimitive();
+        let delegatorState = [];
+        if (_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
+          const krestDelegatorState = _delegatorState.toPrimitive();
+          const delegates = krestDelegatorState === null || krestDelegatorState === void 0 ? void 0 : krestDelegatorState.delegations;
+          delegatorState = delegatorState.concat(delegates);
+        } else {
+          const delegate = _delegatorState.toPrimitive();
+          delegatorState.push(delegate);
+        }
         const unstakingInfo = _unstakingStates[i].toPrimitive();
         if (!delegatorState && !unstakingInfo) {
           stakingCallback(chain, {
@@ -112,8 +133,13 @@ function getMultiStakingAmplitude(substrateApi, useAddresses, chainInfoMap, chai
             unstakings: []
           });
         } else {
-          const activeBalance = delegatorState ? new _util.BN(delegatorState.amount.toString()) : _util.BN_ZERO;
+          let activeBalance = _util.BN_ZERO;
           let unstakingBalance = _util.BN_ZERO;
+          for (const delegate of delegatorState) {
+            var _delegate$amount2;
+            const amount = new _util.BN((_delegate$amount2 = delegate.amount) === null || _delegate$amount2 === void 0 ? void 0 : _delegate$amount2.toString());
+            activeBalance = activeBalance.add(amount);
+          }
           if (unstakingInfo) {
             Object.values(unstakingInfo).forEach(unstakingAmount => {
               const bnUnstakingAmount = new _util.BN(unstakingAmount.toString());
@@ -159,7 +185,7 @@ async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, ne
   });
   const unclaimedRewardList = [];
   await Promise.all(chains.map(async chain => {
-    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_constants._STAKING_CHAIN_GROUP.kilt.includes(chain)) {
+    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_constants._STAKING_CHAIN_GROUP.kilt.includes(chain) && !_constants._STAKING_CHAIN_GROUP.krest_network.includes(chain)) {
       const networkInfo = networks[chain];
       const apiProps = await substrateApiMap[chain].isReady;
       await Promise.all(useAddresses.map(async address => {

package/cjs/koni/api/xcm/xTokens.js

@@ -25,6 +25,6 @@ function getCurrencyId(tokenInfo) {
 }
 function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
   const weightParam = ['pioneer'].includes(originChainInfo.slug) ? _utils.FOUR_INSTRUCTIONS_WEIGHT : (0, _utils.getDestWeight)();
-  const destVersion = ['moonbeam', 'moonriver', 'bifrost_dot', 'interlay', 'hydradx_main', 'acala', 'parallel', 'astar', 'shiden', 'centrifuge'].includes(originChainInfo.slug) ? 'V3' : undefined;
+  const destVersion = ['moonbeam', 'moonriver', 'bifrost_dot', 'interlay', 'hydradx_main', 'acala', 'parallel', 'astar', 'shiden', 'centrifuge', 'manta_network'].includes(originChainInfo.slug) ? 'V3' : undefined;
   return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, (0, _utils.getDestMultilocation)(destinationChainInfo, recipientAddress, destVersion), weightParam);
 }

package/cjs/koni/background/handlers/Tabs.js

@@ -424,15 +424,32 @@ class KoniTabs {
     } = _ref13;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const chainId = params[0].chainId;
+    const chainIdDec = parseInt(chainId, 16);
     const evmState = await this.getEvmState(url);
     if (evmState.chainId === chainId) {
       return null;
     }
-    const [networkKey] = this.#koniState.findNetworkKeyByChainId(parseInt(chainId, 16));
+    const [networkKey] = this.#koniState.findNetworkKeyByChainId(chainIdDec);
     if (networkKey) {
       await this.#koniState.switchEvmNetworkByUrl((0, _utils2.stripUrl)(url), networkKey);
     } else {
-      throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, 'This network is currently not supported');
+      const onlineData = await (0, _utils2.getEVMChainInfo)(chainIdDec);
+      if (onlineData) {
+        const chainData = {
+          chainId: chainId,
+          rpcUrls: onlineData.rpc.filter(url => url.startsWith('https://')),
+          chainName: onlineData.name,
+          blockExplorerUrls: onlineData.explorers.map(explorer => explorer.url),
+          nativeCurrency: onlineData.nativeCurrency,
+          requestId: id
+        };
+        await this.addEvmChain(id, url, {
+          method: 'wallet_addEthereumChain',
+          params: [chainData]
+        });
+      } else {
+        throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, 'This network is currently not supported');
+      }
     }
     return null;
   }

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.1.32-0'
+  version: '1.1.33-0'
 };
 exports.packageInfo = packageInfo;

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

@@ -50,6 +50,7 @@ class CampaignService {
             endTime,
             startTime,
             isDone: false,
+            isArchive: false,
             campaignId,
             type: _KoniTypes.CampaignDataType.BANNER,
             buttons,
@@ -70,6 +71,7 @@ class CampaignService {
           endTime,
           startTime,
           isDone: false,
+          isArchive: false,
           campaignId,
           type: _KoniTypes.CampaignDataType.NOTIFICATION,
           buttons,
@@ -82,6 +84,23 @@ class CampaignService {
       const exists = await this.#state.dbService.getCampaign(campaign.slug);
       if (!exists) {
         await this.#state.dbService.upsertCampaign(campaign);
+      } else {
+        const data = {
+          ...campaign,
+          isDone: exists.isDone
+        };
+        await this.#state.dbService.upsertCampaign(data);
+      }
+    }
+    const allCampaign = await this.#state.dbService.getAllCampaign();
+    for (const stored of allCampaign) {
+      const exists = campaigns.find(campaign => campaign.slug === stored.slug);
+      if (!exists) {
+        const data = {
+          ...stored,
+          isArchive: true
+        };
+        await this.#state.dbService.upsertCampaign(data);
       }
     }
     this.#state.eventService.emit('campaign.ready', true);

package/cjs/services/chain-service/constants.js

@@ -40,7 +40,7 @@ const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge']
@@ -69,8 +69,9 @@ const _STAKING_CHAIN_GROUP = {
   relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network'],
   astar: ['astar', 'shiden', 'shibuya'],
-  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],
   // amplitude and kilt only share some common logic
+  krest_network: ['krest_network'],
   kilt: ['kilt', 'kilt_peregrine'],
   nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network', 'goldberg_testnet'],
   bifrost: ['bifrost', 'bifrost_testnet'],
@@ -111,7 +112,8 @@ const _STAKING_ERA_LENGTH_MAP = {
   creditcoin: 24,
   vara_network: 12,
   goldberg_testnet: 24,
-  manta_network: 6
+  manta_network: 6,
+  krest_network: 4
 };
 exports._STAKING_ERA_LENGTH_MAP = _STAKING_ERA_LENGTH_MAP;
 const _EXPECTED_BLOCK_TIME = {

package/cjs/services/history-service/index.js

@@ -173,14 +173,18 @@ class HistoryService {
 
   // Insert history with check override origin 'app'
   async addHistoryItems(historyItems) {
-    // Prevent override record with original is 'app'
-    const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
-    const excludeKeys = appRecords.map(item => {
-      return `${item.chain}-${item.extrinsicHash}`;
-    });
-    const updateRecords = historyItems.filter(item => {
-      const key = `${item.chain}-${item.extrinsicHash}`;
-      return item.origin === 'app' || !excludeKeys.includes(key);
+    const updateRecords = [];
+    const appItems = this.historySubject.value.filter(i => i.origin === 'app');
+    historyItems.forEach(item => {
+      const needUpdateItem = appItems.find(item_ => item_.extrinsicHash === item.extrinsicHash && item.chain === item_.chain && item.address === item_.address);
+      if (needUpdateItem) {
+        updateRecords.push({
+          ...needUpdateItem,
+          status: item.status
+        });
+        return;
+      }
+      updateRecords.push(item);
     });
     await this.dbService.upsertHistory(updateRecords);
     this.historySubject.next(await this.dbService.getHistories());

package/cjs/services/storage-service/DatabaseService.js

@@ -283,6 +283,9 @@ class DatabaseService {
 
   /* Campaign */
 
+  getAllCampaign() {
+    return this.stores.campaign.getAll();
+  }
   subscribeProcessingCampaign() {
     return this.stores.campaign.subscribeProcessingCampaign();
   }

package/cjs/services/storage-service/db-stores/Campaign.js

@@ -13,7 +13,13 @@ var _dexie = require("dexie");
 const filterProcessing = campaign => {
   const now = new Date().getTime();
   const isExpired = now <= campaign.startTime || now >= campaign.endTime;
-  return !(campaign.isDone || isExpired);
+  return !(campaign.isArchive || campaign.isDone || isExpired);
+};
+const getId = campaign => {
+  return campaign.campaignId;
+};
+const sortById = (a, b) => {
+  return getId(a) - getId(b);
 };
 class CampaignStore extends _BaseStore.default {
   async getAll() {
@@ -23,10 +29,10 @@ class CampaignStore extends _BaseStore.default {
     return this.table.get(slug);
   }
   async getProcessingCampaign() {
-    return (await this.table.toArray()).filter(filterProcessing);
+    return (await this.table.toArray()).filter(filterProcessing).sort(sortById);
   }
   subscribeProcessingCampaign() {
-    return (0, _dexie.liveQuery)(() => this.table.filter(filterProcessing).toArray());
+    return (0, _dexie.liveQuery)(async () => (await this.table.filter(filterProcessing).toArray()).sort(sortById));
   }
   upsertCampaign(campaign) {
     return this.table.put(campaign);

package/cjs/services/transaction-service/index.js

@@ -290,6 +290,12 @@ class TransactionService {
         errors: [...data.errors, new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]
       });
     });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.TIMEOUT)]
+      });
+    });
 
     // Todo: handle any event with transaction.eventsHandler
 
@@ -657,6 +663,45 @@ class TransactionService {
     }
     this.eventService.emit('transaction.failed', transaction);
   }
+  onTimeOut(_ref6) {
+    let {
+      blockHash,
+      blockNumber,
+      errors,
+      extrinsicHash,
+      id
+    } = _ref6;
+    const transaction = this.getTransaction(id);
+    const nextStatus = _KoniTypes.ExtrinsicStatus.TIMEOUT;
+    if (transaction) {
+      this.updateTransaction(id, {
+        status: nextStatus,
+        errors,
+        extrinsicHash
+      });
+      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+        extrinsicHash: extrinsicHash || transaction.extrinsicHash,
+        status: nextStatus,
+        blockNumber: blockNumber || 0,
+        blockHash: blockHash || ''
+      }).catch(console.error);
+      const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.chainService.getChainInfoMap());
+      this.notificationService.notify({
+        type: _KoniTypes.NotificationType.ERROR,
+        title: (0, _i18next.t)('Transaction timed out'),
+        message: (0, _i18next.t)('Transaction {{info}} timed out', {
+          replace: {
+            info
+          }
+        }),
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
+    this.eventService.emit('transaction.timeout', transaction);
+  }
   generateHashPayload(chain, transaction) {
     var _transaction$nonce;
     const chainInfo = this.chainService.getChainInfoByKey(chain);
@@ -671,7 +716,7 @@ class TransactionService {
     };
     return _ethers.ethers.Transaction.from(txObject).unsignedSerialized;
   }
-  async signAndSendEvmTransaction(_ref6) {
+  async signAndSendEvmTransaction(_ref7) {
     var _payload$nonce;
     let {
       address,
@@ -679,7 +724,7 @@ class TransactionService {
       id,
       transaction,
       url
-    } = _ref6;
+    } = _ref7;
     const payload = transaction;
     const evmApi = this.chainService.getEvmApi(chain);
     const chainInfo = this.chainService.getChainInfoByKey(chain);
@@ -747,11 +792,11 @@ class TransactionService {
       extrinsicHash: id
     };
     if (isInjected) {
-      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async _ref7 => {
+      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async _ref8 => {
         let {
           isApproved,
           payload
-        } = _ref7;
+        } = _ref8;
         if (isApproved) {
           if (!payload) {
             throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
@@ -812,11 +857,11 @@ class TransactionService {
         emitter.emit('error', eventData);
       });
     } else {
-      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref8 => {
+      this.requestService.addConfirmation(id, url || _constants3.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref9 => {
         let {
           isApproved,
           payload
-        } = _ref8;
+        } = _ref9;
         if (isApproved) {
           let signedTransaction;
           if (!payload) {
@@ -872,14 +917,14 @@ class TransactionService {
     }
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref9) {
+  signAndSendSubstrateTransaction(_ref10) {
     let {
       address,
       chain,
       id,
       transaction,
       url
-    } = _ref9;
+    } = _ref10;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
@@ -925,20 +970,20 @@ class TransactionService {
           eventData.extrinsicHash = txState.txHash.toHex();
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
-          txState.events.filter(_ref10 => {
+          txState.events.filter(_ref11 => {
             let {
               event: {
                 section
               }
-            } = _ref10;
+            } = _ref11;
             return section === 'system';
-          }).forEach(_ref11 => {
+          }).forEach(_ref12 => {
             let {
               event: {
                 data: [error],
                 method
               }
-            } = _ref11;
+            } = _ref12;
             if (method === 'ExtrinsicFailed') {
               eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
               emitter.emit('error', eventData);
@@ -963,7 +1008,7 @@ class TransactionService {
       const transaction = this.getTransaction(eventData.id);
       if (transaction.status !== _KoniTypes.ExtrinsicStatus.SUCCESS && transaction.status !== _KoniTypes.ExtrinsicStatus.FAIL) {
         eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.TIMEOUT, (0, _i18next.t)('Transaction timeout')));
-        emitter.emit('error', eventData);
+        emitter.emit('timeout', eventData);
         clearTimeout(timeout);
       }
     }, _constants4.TRANSACTION_TIMEOUT);