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

package/services/storage-service/DatabaseService.js

@@ -1,9 +1,9 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { APIItemState, ExtrinsicStatus, StakingType } from '@subwallet/extension-base/background/KoniTypes';
 import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
-import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MetadataV15Store, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
+import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MetadataV15Store, MigrationStore, NftCollectionStore, NftStore, PriceStore, ProcessTransactionStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import CampaignStore from '@subwallet/extension-base/services/storage-service/db-stores/Campaign';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
 import InappNotificationStore from '@subwallet/extension-base/services/storage-service/db-stores/InappNotification';
@@ -11,6 +11,7 @@ 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 { StepStatus } from '@subwallet/extension-base/types';
 import { BN_ZERO, reformatAddress } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
@@ -51,7 +52,9 @@ export default class DatabaseService {
       // assetRef: new AssetRefStore(this._db.assetRef)
 
       // inapp notification
-      inappNotification: new InappNotificationStore(this._db.inappNotification)
+      inappNotification: new InappNotificationStore(this._db.inappNotification),
+      // process transaction
+      processTransactions: new ProcessTransactionStore(this._db.processTransactions)
     };
   }
   async updatePriceStore(priceData) {
@@ -260,15 +263,90 @@ export default class DatabaseService {
     const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
     return this.stores.transaction.bulkUpsert(cleanedHistory);
   }
-  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData, isRecover) {
     const canUpdate = updateData && extrinsicHash;
     if (!canUpdate) {
       return;
     }
+    if (isRecover) {
+      await this.recoverProcessTransaction(extrinsicHash, updateData);
+    }
     return this.stores.transaction.updateWithQuery({
       extrinsicHash
     }, updateData);
   }
+  async restoreProcessTransaction() {
+    const processes = await this.stores.processTransactions.getSubmittingProcess();
+    const queuedProcesses = processes.filter(process => process.status === StepStatus.QUEUED);
+    const processingProcesses = processes.filter(process => process.status === StepStatus.PROCESSING);
+    await this.stores.processTransactions.bulkDelete(queuedProcesses.map(process => process.id));
+    for (const process of processingProcesses) {
+      const currentStepId = process.currentStepId;
+      const currentStep = process.steps.find(step => step.id === currentStepId);
+      if (currentStep) {
+        const currentStepStatus = currentStep.status;
+        if ([StepStatus.QUEUED, StepStatus.PREPARE].includes(currentStepStatus)) {
+          currentStep.status = StepStatus.CANCELLED;
+          process.status = StepStatus.CANCELLED;
+        } else if (currentStepStatus === StepStatus.TIMEOUT) {
+          currentStep.status = StepStatus.CANCELLED;
+        }
+        const nextSteps = process.steps.filter(step => step.id > currentStepId);
+        for (const step of nextSteps) {
+          step.status = StepStatus.CANCELLED;
+        }
+      }
+    }
+    await this.stores.processTransactions.bulkUpsert(processingProcesses);
+  }
+  async recoverProcessTransaction(extrinsicHash, updateData) {
+    const txs = await this.stores.transaction.queryHistory({
+      extrinsicHash
+    });
+    const map = new Map(txs.filter(x => !!x.processId && x.extrinsicHash === extrinsicHash).map(tx => [tx.processId || '', tx.transactionId || '']));
+    if (map.size && updateData.status) {
+      const processes = await this.stores.processTransactions.getByIds(Array.from(map.keys()));
+      for (const [processId, process] of Object.entries(processes)) {
+        const txId = map.get(processId);
+        if (txId) {
+          const currentStep = process.steps.find(tx => tx.transactionId === txId);
+          if (currentStep) {
+            const differentHash = txId !== extrinsicHash && currentStep.extrinsicHash !== extrinsicHash;
+            if (currentStep.status === StepStatus.PROCESSING || currentStep.status === StepStatus.SUBMITTING) {
+              switch (updateData.status) {
+                case ExtrinsicStatus.SUCCESS:
+                  currentStep.status = StepStatus.COMPLETE;
+                  if (differentHash) {
+                    currentStep.extrinsicHash = extrinsicHash;
+                  }
+                  break;
+                case ExtrinsicStatus.FAIL:
+                  currentStep.status = StepStatus.FAILED;
+                  if (differentHash) {
+                    currentStep.extrinsicHash = extrinsicHash;
+                  }
+                  break;
+                case ExtrinsicStatus.UNKNOWN:
+                  currentStep.status = StepStatus.TIMEOUT;
+                  break;
+              }
+            }
+            const isLastStep = process.steps[process.steps.length - 1].id === currentStep.id;
+            if (isLastStep) {
+              process.status = currentStep.status;
+            } else {
+              if (currentStep.status === StepStatus.TIMEOUT) {
+                process.status = StepStatus.TIMEOUT;
+              } else {
+                process.status = StepStatus.CANCELLED;
+              }
+            }
+            await this.stores.processTransactions.upsert(process);
+          }
+        }
+      }
+    }
+  }
 
   // NFT Collection
   async addNftCollection(collection) {
@@ -543,6 +621,24 @@ export default class DatabaseService {
   async getExportJson() {
     return JSON.parse(await this.exportDB());
   }
+  upsertProcessTransaction(processTransaction) {
+    return this.stores.processTransactions.upsert(processTransaction);
+  }
+  observableProcessTransactions() {
+    return this.stores.processTransactions.observableAll();
+  }
+  getProcessTransactions() {
+    return this.stores.processTransactions.getAll();
+  }
+  getProcessTransactionById(processId) {
+    return this.stores.processTransactions.getOne(processId);
+  }
+  observableProcessTransactionById(processId) {
+    return this.stores.processTransactions.observableOne(processId);
+  }
+  deleteProcessTransactionById(processId) {
+    return this.stores.processTransactions.delete(processId);
+  }
 
   // public setAssetRef (assetRef: Record<string, _AssetRef>) {
   //   const assetRefList = Object.entries(assetRef).map(([slug, item]) => {

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

@@ -1,7 +1,7 @@
 import { _AssetRef, _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { CampaignData, ChainStakingMetadata, CrowdloanItem, MetadataItem, MetadataV15Item, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import { _NotificationInfo } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
-import { BalanceItem, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
+import { BalanceItem, ProcessTransactionData, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
 import Dexie, { Table } from 'dexie';
 export declare const DEFAULT_DATABASE = "SubWalletDB_v2";
 export interface DefaultChainDoc {
@@ -64,6 +64,7 @@ export default class KoniDatabase extends Dexie {
     campaign: Table<ICampaign, object>;
     keyValue: Table<IKeyValue, object>;
     inappNotification: Table<_NotificationInfo, object>;
+    processTransactions: Table<ProcessTransactionData, object>;
     private schemaVersion;
     constructor(name?: string, schemaVersion?: number);
     private conditionalVersion;

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

@@ -46,6 +46,9 @@ export default class KoniDatabase extends Dexie {
     this.conditionalVersion(8, {
       metadataV15: 'genesisHash, chain'
     });
+    this.conditionalVersion(9, {
+      processTransactions: 'id, address'
+    });
   }
   conditionalVersion(version, schema, upgrade) {
     if (this.schemaVersion != null && this.schemaVersion < version) {

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

@@ -0,0 +1,14 @@
+import { ProcessTransactionData } from '@subwallet/extension-base/types';
+import BaseStoreWithAddress from './BaseStoreWithAddress';
+export default class ProcessTransaction extends BaseStoreWithAddress<ProcessTransactionData> {
+    getAll(): Promise<Record<string, ProcessTransactionData>>;
+    observableAll(): import("dexie").Observable<Record<string, ProcessTransactionData>>;
+    getOne(id: string): Promise<ProcessTransactionData | undefined>;
+    observableOne(id: string): import("dexie").Observable<ProcessTransactionData | undefined>;
+    getByIds(ids: string[]): Promise<{
+        [k: string]: ProcessTransactionData;
+    }>;
+    delete(key: string): Promise<void>;
+    getSubmittingProcess(): import("dexie").PromiseExtended<ProcessTransactionData[]>;
+    bulkDelete(keys: string[]): Promise<void>;
+}

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

@@ -0,0 +1,39 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StepStatus } from '@subwallet/extension-base/types';
+import { liveQuery } from 'dexie';
+import BaseStoreWithAddress from "./BaseStoreWithAddress.js";
+export default class ProcessTransaction extends BaseStoreWithAddress {
+  async getAll() {
+    const all = await this.table.toArray();
+    return Object.fromEntries(all.map(item => [item.id, item]));
+  }
+  observableAll() {
+    return liveQuery(async () => {
+      const all = await this.table.toArray();
+      return Object.fromEntries(all.map(item => [item.id, item]));
+    });
+  }
+  async getOne(id) {
+    return this.table.get(id);
+  }
+  observableOne(id) {
+    return liveQuery(async () => {
+      return this.table.get(id);
+    });
+  }
+  async getByIds(ids) {
+    const rs = await this.table.where('id').anyOf(ids).toArray();
+    return Object.fromEntries(rs.map(item => [item.id, item]));
+  }
+  delete(key) {
+    return this.table.delete(key);
+  }
+  getSubmittingProcess() {
+    return this.table.filter(item => [StepStatus.PROCESSING, StepStatus.QUEUED].includes(item.status)).toArray();
+  }
+  bulkDelete(keys) {
+    return this.table.bulkDelete(keys);
+  }
+}

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

@@ -10,6 +10,8 @@ export default class TransactionStore extends BaseStoreWithAddressAndChain {
     }
     return this.table.where('address').equals(address).toArray();
   }
+
+  // TODO: This query is not exactly correct. It makes a lot of wrong assumptions, need to be fixed.
   async queryHistory(query) {
     if (!(query !== null && query !== void 0 && query.address) && !(query !== null && query !== void 0 && query.chain)) {
       return this.table.toArray();

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

@@ -10,3 +10,4 @@ export { default as MetadataStore } from './Metadata';
 export { default as MetadataV15Store } from './MetadataV15';
 export { default as ChainStore } from './Chain';
 export { default as AssetStore } from './Asset';
+export { default as ProcessTransactionStore } from './ProcessTransaction';

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

@@ -12,4 +12,5 @@ export { default as MigrationStore } from "./Migration.js";
 export { default as MetadataStore } from "./Metadata.js";
 export { default as MetadataV15Store } from "./MetadataV15.js";
 export { default as ChainStore } from "./Chain.js";
-export { default as AssetStore } from "./Asset.js";
+export { default as AssetStore } from "./Asset.js";
+export { default as ProcessTransactionStore } from "./ProcessTransaction.js";

package/services/swap-service/handler/asset-hub/handler.js

@@ -4,6 +4,7 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { _getEarlyAssetHubValidationError, _validateBalanceToSwapOnAssetHub, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
@@ -20,7 +21,18 @@ export class AssetHubSwapHandler {
   isReady = false;
   constructor(chainService, balanceService, feeService, chain) {
     const chainInfo = chainService.getChainInfoByKey(chain);
-    const providerSlug = chain === 'statemint' ? SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? SwapProviderId.KUSAMA_ASSET_HUB : SwapProviderId.ROCOCO_ASSET_HUB;
+    const providerSlug = function () {
+      switch (chain) {
+        case 'statemint':
+          return SwapProviderId.POLKADOT_ASSET_HUB;
+        case 'statemine':
+          return SwapProviderId.KUSAMA_ASSET_HUB;
+        case 'westend_assethub':
+          return SwapProviderId.WESTEND_ASSET_HUB;
+        default:
+          return SwapProviderId.ROCOCO_ASSET_HUB;
+      }
+    }();
     this.swapBaseHandler = new SwapBaseHandler({
       balanceService,
       chainService,
@@ -78,21 +90,13 @@ export class AssetHubSwapHandler {
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
       const originalChainInfo = this.chainService.getChainInfoByKey(this.chain);
-      const step = {
-        metadata: {
-          sendingValue: bnAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: CommonStepType.XCM
-      };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
       const id = getId();
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeChainInfo.slug, 'substrate');
       const xcmTransfer = await createXcmExtrinsic({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
+        // Mock sending value to get payment info
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
         sender: params.request.address,
@@ -106,12 +110,27 @@ export class AssetHubSwapHandler {
       const fee = {
         feeComponent: [{
           feeType: SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          amount: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: _getChainNativeTokenSlug(alternativeChainInfo)
         }],
         defaultFeeToken: _getChainNativeTokenSlug(alternativeChainInfo),
         feeOptions: [_getChainNativeTokenSlug(alternativeChainInfo)]
       };
+      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
+      if (_isNativeToken(alternativeAsset)) {
+        const bnXcmFee = new BigN(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
+
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: alternativeAsset,
+          destinationTokenInfo: fromAsset
+        },
+        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
       return [step, fee];
     } catch (e) {
       console.error('Error creating xcm step', e);

package/services/swap-service/handler/hydradx-handler.js

@@ -7,6 +7,7 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { _getEarlyHydradxValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _getAssetDecimals, _getChainNativeTokenSlug, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
@@ -92,21 +93,13 @@ export class HydradxHandler {
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
       const destChainInfo = this.chainService.getChainInfoByKey(this.chain());
-      const step = {
-        metadata: {
-          sendingValue: bnAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: CommonStepType.XCM
-      };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
       const id = getId();
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeAsset.originChain, 'substrate');
       const xcmTransfer = await createXcmExtrinsic({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
+        // Mock sending value to get payment info
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
         substrateApi: xcmOriginSubstrateApi,
@@ -120,12 +113,27 @@ export class HydradxHandler {
       const fee = {
         feeComponent: [{
           feeType: SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          amount: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: _getChainNativeTokenSlug(alternativeChainInfo)
         }],
         defaultFeeToken: _getChainNativeTokenSlug(alternativeChainInfo),
         feeOptions: [_getChainNativeTokenSlug(alternativeChainInfo)]
       };
+      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
+      if (_isNativeToken(alternativeAsset)) {
+        const bnXcmFee = new BigNumber(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
+
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: alternativeAsset,
+          destinationTokenInfo: fromAsset
+        },
+        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
       return [step, fee];
     } catch (e) {
       console.error('Error creating xcm step', e);

package/services/swap-service/index.js

@@ -158,6 +158,9 @@ export class SwapService {
         case SwapProviderId.ROCOCO_ASSET_HUB:
           this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
           break;
+        case SwapProviderId.WESTEND_ASSET_HUB:
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'westend_assethub');
+          break;
         case SwapProviderId.SIMPLE_SWAP:
           this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;

package/services/swap-service/utils.js

@@ -51,6 +51,7 @@ export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [SwapProviderId.POLKADOT_ASSET_HUB]: [COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
   [SwapProviderId.KUSAMA_ASSET_HUB]: [COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
   [SwapProviderId.ROCOCO_ASSET_HUB]: [COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
+  [SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub'],
   [SwapProviderId.SIMPLE_SWAP]: ['bittensor', COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.POLKADOT]
 };
 export function getSwapAlternativeAsset(swapPair) {

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

@@ -1,17 +1,20 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { SWTransaction, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
+import { BriefProcessStep, ProcessStep, ProcessTransactionData } from '@subwallet/extension-base/types';
 import { BehaviorSubject } from 'rxjs';
 import { TransactionConfig } from 'web3-core';
 import { HexString } from '@polkadot/util/types';
 export default class TransactionService {
     private readonly state;
-    private readonly transactionSubject;
     private readonly eventService;
     private readonly historyService;
     private readonly notificationService;
     private readonly chainService;
     private readonly watchTransactionSubscribes;
+    private aliveProcessMap;
+    private readonly transactionSubject;
+    private readonly aliveProcessSubject;
     private get transactions();
     constructor(state: KoniState);
     private get allTransactions();
@@ -20,6 +23,15 @@ export default class TransactionService {
     private checkDuplicate;
     validateTransaction(transactionInput: SWTransactionInput): Promise<SWTransactionResponse>;
     getTransactionSubject(): BehaviorSubject<Record<string, SWTransaction>>;
+    get observables(): {
+        readonly transaction: import("rxjs").Observable<Record<string, SWTransaction>>;
+        readonly aliveProcess: import("rxjs").Observable<Record<string, ProcessTransactionData>>;
+    };
+    get values(): {
+        readonly transaction: Record<string, SWTransaction>;
+        readonly aliveProcess: Record<string, ProcessTransactionData>;
+    };
+    private updateAliveProcess;
     private fillTransactionDefaultInfo;
     addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;
     generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
@@ -42,5 +54,11 @@ export default class TransactionService {
     private signAndSendTonTransaction;
     private handleTransactionTimeout;
     private handlePostEarningTransaction;
+    createProcessIfNeed(process: ProcessTransactionData): Promise<void>;
+    checkProcessExist(processId: string): boolean;
+    private deleteProcess;
+    updateProcessStepStatus(step: BriefProcessStep, data: Pick<ProcessStep, 'status' | 'transactionId' | 'extrinsicHash' | 'chain'>): void;
+    updateProcessInfo(id: string, combineInfo: unknown, step?: ProcessStep): Promise<void>;
+    createProcessNotification(transactionId: string): Promise<void>;
     resetWallet(): void;
 }