@subwallet/extension-base 1.3.20-0 → 1.3.22-0

package/services/earning-service/handlers/native-staking/mythos.js

@@ -0,0 +1,329 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { getCommission } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _EXPECTED_BLOCK_TIME, _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
+import { BasicTxErrorType, EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
+export default class MythosNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: false,
+    withdraw: true,
+    claimReward: true
+  };
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const nativeToken = this.nativeToken;
+    const defaultCallback = async () => {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      const poolInfo = await this.getPoolInfo();
+      !poolInfo && callback(data);
+    };
+    if (!this.isActive) {
+      await defaultCallback();
+      return () => {
+        cancel = true;
+      };
+    }
+    await defaultCallback();
+    await substrateApi.isReady;
+    const unsub = await substrateApi.api.query.collatorStaking.currentSession(async _session => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const currentSession = _session.toString();
+      const maxStakers = substrateApi.api.consts.collatorStaking.maxStakers.toString();
+      const unstakeDelay = substrateApi.api.consts.collatorStaking.stakeUnlockDelay.toString();
+      const maxStakedCandidates = substrateApi.api.consts.collatorStaking.maxStakedCandidates.toString();
+      const sessionTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
+      const blockTime = _EXPECTED_BLOCK_TIME[this.chain];
+      const unstakingPeriod = parseInt(unstakeDelay) * blockTime / 60 / 60;
+      const _minStake = await substrateApi.api.query.collatorStaking.minStake();
+      const minStake = _minStake.toString();
+      const minStakeToHuman = formatNumber(minStake, nativeToken.decimals || 0, balanceFormatter);
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minStakeToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: parseInt(maxStakedCandidates),
+          maxWithdrawalRequestPerFarmer: 3,
+          earningThreshold: {
+            join: minStake,
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          era: parseInt(currentSession),
+          eraTime: sessionTime,
+          unstakingPeriod: unstakingPeriod,
+          totalApy: undefined
+          // tvl: totalStake.toString(),
+          // inflation
+        },
+
+        maxPoolMembers: parseInt(maxStakers)
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const unsub = await substrateApi.api.query.collatorStaking.userStake.multi(useAddresses, async userStakes => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (userStakes) {
+        await Promise.all(userStakes.map(async (_userStake, i) => {
+          const userStake = _userStake.toPrimitive();
+          const owner = reformatAddress(useAddresses[i], 42);
+          if (userStake) {
+            const nominatorMetadata = await this.parseCollatorMetadata(this.chainInfo, useAddresses[i], substrateApi, userStake);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+  async parseCollatorMetadata(chainInfo, stakerAddress, substrateApi, userStake) {
+    const nominationList = [];
+    const unstakingList = [];
+    let unstakingBalance = BigInt(0);
+    const {
+      candidates,
+      stake
+    } = userStake;
+    const [_minStake, _unstaking, _currentBlock, _currentTimestamp] = await Promise.all([substrateApi.api.query.collatorStaking.minStake(), substrateApi.api.query.collatorStaking.releaseQueues(stakerAddress), substrateApi.api.query.system.number(), substrateApi.api.query.timestamp.now()]);
+    const minStake = _minStake.toPrimitive();
+    const stakingStatus = candidates && !!candidates.length ? EarningStatus.EARNING_REWARD : EarningStatus.NOT_EARNING;
+    const isBondedBefore = candidates && !!candidates.length;
+    const unstakings = _unstaking.toPrimitive();
+    const currentBlock = _currentBlock.toPrimitive();
+    const currentTimestamp = _currentTimestamp.toPrimitive();
+    const blockDuration = _EXPECTED_BLOCK_TIME[chainInfo.slug];
+    if (candidates.length) {
+      await Promise.all(candidates.map(async collatorAddress => {
+        const _stakeInfo = await substrateApi.api.query.collatorStaking.candidateStake(collatorAddress, stakerAddress);
+        const stakeInfo = _stakeInfo.toPrimitive();
+        const activeStake = stakeInfo.stake.toString();
+        const earningStatus = BigInt(activeStake) > BigInt(0) && BigInt(activeStake) >= BigInt(minStake) ? EarningStatus.EARNING_REWARD : EarningStatus.NOT_EARNING;
+        nominationList.push({
+          status: earningStatus,
+          chain: chainInfo.slug,
+          validatorAddress: collatorAddress,
+          activeStake,
+          validatorMinStake: minStake,
+          hasUnstaking: !!unstakings.length
+        });
+      }));
+    }
+    if (unstakings.length) {
+      unstakings.forEach(unstaking => {
+        const releaseBlock = unstaking.block;
+        const unstakeAmount = unstaking.amount;
+        const isClaimable = currentBlock >= releaseBlock;
+        const targetTimestampMs = (releaseBlock - currentBlock) * blockDuration * 1000 + currentTimestamp;
+        unstakingBalance = unstakingBalance + BigInt(unstakeAmount);
+        unstakingList.push({
+          chain: chainInfo.slug,
+          status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+          claimable: unstakeAmount,
+          targetTimestampMs
+        });
+      });
+    }
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: (BigInt(stake) + unstakingBalance).toString(),
+      activeStake: stake,
+      unstakeBalance: unstakingBalance.toString() || '0',
+      isBondedBefore: isBondedBefore,
+      nominations: nominationList,
+      unstakings: unstakingList
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const substrateApi = await this.substrateApi.isReady;
+    const [_allCollators, _minStake, _commission] = await Promise.all([substrateApi.api.query.collatorStaking.candidates.entries(), substrateApi.api.query.collatorStaking.minStake(), substrateApi.api.query.collatorStaking.collatorRewardPercentage()]);
+    const maxStakersPerCollator = substrateApi.api.consts.collatorStaking.maxStakers.toPrimitive();
+    return _allCollators.map(_collator => {
+      const _collatorAddress = _collator[0].toHuman();
+      const collatorAddress = _collatorAddress[0];
+      const collatorInfo = _collator[1].toPrimitive();
+      const bnTotalStake = BigInt(collatorInfo.stake);
+      const numOfStakers = parseInt(collatorInfo.stakers);
+      const isCrowded = numOfStakers >= maxStakersPerCollator;
+      return {
+        address: collatorAddress,
+        chain: this.chain,
+        totalStake: bnTotalStake.toString(),
+        ownStake: '0',
+        otherStake: bnTotalStake.toString(),
+        minBond: _minStake.toPrimitive(),
+        nominatorCount: numOfStakers,
+        commission: getCommission(_commission.toString()),
+        blocked: false,
+        isVerified: false,
+        isCrowded
+      };
+    });
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    var _substrateApi$api$cal, _substrateApi$api$cal2;
+    const substrateApi = await this.substrateApi.isReady;
+    const {
+      address,
+      amount,
+      selectedValidators
+    } = data;
+    const selectedValidatorInfo = selectedValidators[0];
+    const _hasReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.collatorStakingApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.shouldClaim(address));
+    const hasReward = _hasReward === null || _hasReward === void 0 ? void 0 : _hasReward.toPrimitive();
+    const extrinsicList = [];
+    if (positionInfo !== null && positionInfo !== void 0 && positionInfo.isBondedBefore && hasReward) {
+      extrinsicList.push(substrateApi.api.tx.collatorStaking.claimRewards());
+    }
+    extrinsicList.push(...[substrateApi.api.tx.collatorStaking.lock(amount), substrateApi.api.tx.collatorStaking.stake([{
+      candidate: selectedValidatorInfo.address,
+      stake: amount
+    }])]);
+    return [substrateApi.api.tx.utility.batchAll(extrinsicList), {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    var _substrateApi$api$cal3, _substrateApi$api$cal4;
+    const substrateApi = await this.substrateApi.isReady;
+    const _hasReward = await ((_substrateApi$api$cal3 = substrateApi.api.call) === null || _substrateApi$api$cal3 === void 0 ? void 0 : (_substrateApi$api$cal4 = _substrateApi$api$cal3.collatorStakingApi) === null || _substrateApi$api$cal4 === void 0 ? void 0 : _substrateApi$api$cal4.shouldClaim(address));
+    const hasReward = _hasReward === null || _hasReward === void 0 ? void 0 : _hasReward.toPrimitive();
+    const extrinsicList = [];
+    if (hasReward) {
+      extrinsicList.push(substrateApi.api.tx.collatorStaking.claimRewards());
+    }
+    extrinsicList.push(...[substrateApi.api.tx.collatorStaking.unstakeFrom(selectedTarget), substrateApi.api.tx.collatorStaking.unlock(null) // ignore amount to unlock all
+    ]);
+
+    return [ExtrinsicType.STAKING_UNBOND, substrateApi.api.tx.utility.batchAll(extrinsicList)];
+  }
+
+  /* Leave pool action */
+
+  /* Get pool reward */
+  async getPoolReward(useAddresses, callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    if (substrateApi.api.call.collatorStakingApi) {
+      await Promise.all(useAddresses.map(async address => {
+        if (!cancel) {
+          const _unclaimedReward = await substrateApi.api.call.collatorStakingApi.totalRewards(address);
+          const earningRewardItem = {
+            ...this.baseInfo,
+            address: address,
+            type: this.type,
+            unclaimedReward: (_unclaimedReward === null || _unclaimedReward === void 0 ? void 0 : _unclaimedReward.toString()) || '0',
+            state: APIItemState.READY
+          };
+          if (_unclaimedReward.toString() !== '0') {
+            await this.createClaimNotification(earningRewardItem, this.nativeToken);
+          }
+          callback(earningRewardItem);
+        }
+      }));
+    }
+    return () => {
+      cancel = false;
+    };
+  }
+  /* Get pool reward */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake() {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const substrateApi = await this.substrateApi.isReady;
+    return substrateApi.api.tx.collatorStaking.release();
+  }
+  async handleYieldClaimReward(address, bondReward) {
+    const substrateApi = await this.substrateApi.isReady;
+    return substrateApi.api.tx.collatorStaking.claimRewards();
+  }
+  /* Other action */
+}

package/services/earning-service/handlers/special.js

@@ -3,10 +3,10 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { ALL_ACCOUNT_KEY, XCM_FEE_RATIO } from '@subwallet/extension-base/constants';
+import { ALL_ACCOUNT_KEY, XCM_FEE_RATIO, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { YIELD_POOL_STAT_REFRESH_INTERVAL } from '@subwallet/extension-base/koni/api/yield/helper/utils';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetName, _getAssetSymbol, _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetName, _getAssetSymbol, _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
 import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -216,15 +216,6 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
           const symbol = altInputTokenInfo.symbol;
           const networkName = altChainInfo.name;
-          const step = {
-            metadata: {
-              sendingValue: bnAmount.toString(),
-              originTokenInfo: altInputTokenInfo,
-              destinationTokenInfo: inputTokenInfo
-            },
-            name: `Transfer ${symbol} from ${networkName}`,
-            type: YieldStepType.XCM
-          };
           const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
           const id = getId();
           const feeInfo = await this.state.feeService.subscribeChainFee(id, altChainInfo.slug, 'substrate');
@@ -245,9 +236,24 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
 
           const fee = {
             slug: altInputTokenSlug,
-            amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString() // TODO
+            amount: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString() // TODO
           };
 
+          let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
+          if (_isNativeToken(altInputTokenInfo)) {
+            const bnXcmFee = new BN(fee.amount || 0); // xcm fee is paid in native token but swap token is not always native token
+
+            bnTransferAmount = bnTransferAmount.add(bnXcmFee);
+          }
+          const step = {
+            metadata: {
+              sendingValue: bnTransferAmount.toString(),
+              originTokenInfo: altInputTokenInfo,
+              destinationTokenInfo: inputTokenInfo
+            },
+            name: `Transfer ${symbol} from ${networkName}`,
+            type: YieldStepType.XCM
+          };
           return [step, fee];
         }
       }

package/services/earning-service/service.js

@@ -8,6 +8,7 @@ import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
 import BaseLiquidStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base';
+import MythosNativeStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/mythos';
 import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
 import { addLazy, categoryAddresses, createPromiseHandler, removeLazy } from '@subwallet/extension-base/utils';
 import { fetchStaticCache } from '@subwallet/extension-base/utils/fetchStaticCache';
@@ -68,6 +69,9 @@ export default class EarningService {
       if (_STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
         handlers.push(new TaoNativeStakingPoolHandler(this.state, chain));
       }
+      if (_STAKING_CHAIN_GROUP.mythos.includes(chain)) {
+        handlers.push(new MythosNativeStakingPoolHandler(this.state, chain));
+      }
       if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new NominationPoolHandler(this.state, chain));
       }

package/services/earning-service/utils/index.js

@@ -105,6 +105,8 @@ export function isActionFromValidator(stakingType, chain) {
     return true;
   } else if (_STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
     return true;
+  } else if (_STAKING_CHAIN_GROUP.mythos.includes(chain)) {
+    return true;
   }
   return false;
 }

package/services/history-service/helpers/recoverHistoryStatus.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { isSameAddress } from '@subwallet/extension-base/utils';
+import { isHex } from '@polkadot/util';
 export let HistoryRecoverStatus;
 (function (HistoryRecoverStatus) {
   HistoryRecoverStatus["SUCCESS"] = "SUCCESS";
@@ -31,7 +32,7 @@ const substrateRecover = async (history, chainService) => {
       const _api = await substrateApi.isReady;
       const api = _api.api;
       if (!blockHash) {
-        if (!nonce || !startBlock) {
+        if (nonce === undefined || startBlock === undefined) {
           console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
           return {
             status: HistoryRecoverStatus.LACK_INFO
@@ -41,7 +42,7 @@ const substrateRecover = async (history, chainService) => {
         for (let i = 1, found = false; i < BLOCK_LIMIT && !found && startBlock + i <= currentBlock; i++) {
           const blockHash = (await api.rpc.chain.getBlockHash(startBlock + i)).toHex();
           const block = await api.rpc.chain.getBlock(blockHash);
-          const extrinsics = block.block.extrinsics;
+          const extrinsics = block.block.extrinsics.toArray();
           let index;
           for (const [idx, extrinsic] of Object.entries(extrinsics)) {
             if (extrinsic.signer && isSameAddress(from, extrinsic.signer.toString()) && nonce === extrinsic.nonce.toNumber()) {
@@ -142,16 +143,24 @@ const evmRecover = async (history, chainService) => {
   try {
     const evmApi = chainService.getEvmApi(chain);
     if (evmApi) {
-      const _api = await evmApi.isReady;
+      const _api = await Promise.race([evmApi.isReady, new Promise((resolve, reject) => {
+        const createTimeout = callback => {
+          setTimeout(callback, 10000);
+        };
+        createTimeout(() => {
+          const api = chainService.getEvmApi(chain);
+          Promise.race([api.isReady, new Promise((resolve, reject) => createTimeout(() => reject(new Error('Timeout'))))]).then(resolve).catch(reject);
+        });
+      })]);
       const api = _api.api;
-      if (extrinsicHash) {
+      if (extrinsicHash && isHex(extrinsicHash)) {
         const transactionReceipt = await api.eth.getTransactionReceipt(extrinsicHash);
         return {
           ...result,
           status: transactionReceipt.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED
         };
       } else {
-        if (!nonce || !startBlock) {
+        if (nonce === undefined || startBlock === undefined) {
           console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
           return {
             ...result,

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

@@ -1,4 +1,4 @@
-import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import { PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
@@ -18,18 +18,18 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
     private fetchPromise;
     private recoverInterval;
     private fetchAndLoadHistories;
-    getHistories(): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
-    getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>>;
+    getHistories(): Promise<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>;
+    getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>>;
     /**
      * @todo: Must improve performance of this function
      * */
     private fetchSubscanTransactionHistory;
     subscribeHistories(chain: string, proxyId: string, cb: (items: TransactionHistoryItem[]) => void): {
         unsubscribe: () => void;
-        value: TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[];
+        value: TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[];
     };
     updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
-    updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
+    updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>, isRecover?: boolean): Promise<void>;
     insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
     addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
     removeHistoryByAddress(address: string): Promise<void>;
@@ -45,6 +45,7 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
         promise: Promise<void>;
     };
     init(): Promise<void>;
+    restoreProcessTransaction(): Promise<void>;
     recoverProcessingHistory(): Promise<void>;
     start(): Promise<void>;
     waitForStarted(): Promise<void>;

package/services/history-service/index.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { ExtrinsicStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_RECOVER_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEvmCompatible, _isChainSubstrateCompatible } from '@subwallet/extension-base/services/chain-service/utils';
@@ -177,8 +177,8 @@ export class HistoryService {
     });
     await this.addHistoryItems(updatedRecords);
   }
-  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
-    await this.dbService.updateHistoryByExtrinsicHash(extrinsicHash, updateData);
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData, isRecover = false) {
+    await this.dbService.updateHistoryByExtrinsicHash(extrinsicHash, updateData, isRecover);
     this.historySubject.next(await this.dbService.getHistories());
   }
 
@@ -253,11 +253,11 @@ export class HistoryService {
         case HistoryRecoverStatus.FAILED:
         case HistoryRecoverStatus.SUCCESS:
           updateData.status = recoverResult.status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL;
-          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData, true).catch(console.error);
           delete this.#needRecoveryHistories[currentExtrinsicHash];
           break;
         default:
-          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData, true).catch(console.error);
           delete this.#needRecoveryHistories[currentExtrinsicHash];
       }
     });
@@ -269,6 +269,7 @@ export class HistoryService {
   async init() {
     this.status = ServiceStatus.INITIALIZING;
     await this.eventService.waitCryptoReady;
+    this.restoreProcessTransaction().catch(console.error);
     await this.loadData();
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
@@ -279,11 +280,21 @@ export class HistoryService {
     }).catch(console.error);
     this.status = ServiceStatus.INITIALIZED;
   }
+  async restoreProcessTransaction() {
+    await this.dbService.restoreProcessTransaction();
+  }
   async recoverProcessingHistory() {
     const histories = await this.dbService.getHistories();
     this.#needRecoveryHistories = {};
     histories.filter(history => {
       return [ExtrinsicStatus.PROCESSING, ExtrinsicStatus.SUBMITTING].includes(history.status);
+    }).filter(history => {
+      if (history.type === ExtrinsicType.TRANSFER_XCM) {
+        const data = history.additionalInfo;
+        return data.originalChain === history.chain;
+      } else {
+        return true;
+      }
     }).forEach(history => {
       this.#needRecoveryHistories[history.extrinsicHash] = history;
     });

package/services/inapp-notification-service/index.d.ts

@@ -6,6 +6,7 @@ import { _BaseNotificationInfo, _NotificationInfo, NotificationActionType } from
 import { AvailBridgeTransaction, PolygonTransaction } from '@subwallet/extension-base/services/inapp-notification-service/utils';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { ProcessTransactionData } from '@subwallet/extension-base/types';
 import { GetNotificationParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
 export declare class InappNotificationService implements CronServiceInterface {
     private readonly dbService;
@@ -36,6 +37,7 @@ export declare class InappNotificationService implements CronServiceInterface {
     processWriteAvailBridgeClaim(address: string, transactions: AvailBridgeTransaction[], token: _ChainAsset): Promise<void>;
     createPolygonClaimableTransactions(): Promise<void>;
     processPolygonClaimNotification(address: string, transactions: PolygonTransaction[], token: _ChainAsset): Promise<void>;
+    createProcessNotification(process: ProcessTransactionData): Promise<void>;
     start(): Promise<void>;
     startCron(): Promise<void>;
     stop(): Promise<void>;