@subwallet/extension-base 1.1.54-0 → 1.1.56-0

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

@@ -1446,6 +1446,27 @@ class KoniExtension {
       throw new Error((0, _i18next.t)('Wrong password'));
     }
   }
+  async batchExportV2(_ref44) {
+    let {
+      addresses,
+      password
+    } = _ref44;
+    try {
+      if (addresses && !addresses.length) {
+        throw new Error((0, _i18next.t)('No accounts found to export'));
+      }
+      return {
+        exportedJson: await _uiKeyring.keyring.backupAccounts(password, addresses)
+      };
+    } catch (e) {
+      const error = e;
+      if (error.message === 'Invalid master password') {
+        throw new Error((0, _i18next.t)('Wrong password'));
+      } else {
+        throw error;
+      }
+    }
+  }
   getNftCollection() {
     return this.#koniState.getNftCollection();
   }
@@ -1532,11 +1553,11 @@ class KoniExtension {
     // Re-filter
     return historySubject.getValue().filter(item => addresses.some(address => (0, _utils4.isSameAddress)(item.address, address)));
   }
-  subscribeHistoryByChainAndAddress(_ref44, id, port) {
+  subscribeHistoryByChainAndAddress(_ref45, id, port) {
     let {
       address,
       chain
-    } = _ref44;
+    } = _ref45;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscribeHistoriesResponse = this.#koniState.historyService.subscribeHistories(chain, address, cb);
     this.createUnsubscriptionHandle(id, subscribeHistoriesResponse.unsubscribe);
@@ -1852,21 +1873,21 @@ class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(_ref45) {
+  async enableChain(_ref46) {
     let {
       chainSlug,
       enableTokens
-    } = _ref45;
+    } = _ref46;
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
   async reconnectChain(chainSlug) {
     return this.#koniState.chainService.reconnectChain(chainSlug);
   }
-  async validateNetwork(_ref46) {
+  async validateNetwork(_ref47) {
     let {
       existedChainSlug,
       provider
-    } = _ref46;
+    } = _ref47;
     return await this.#koniState.validateCustomChain(provider, existedChainSlug);
   }
   resetDefaultNetwork() {
@@ -1904,12 +1925,12 @@ class KoniExtension {
   async validateCustomAsset(data) {
     return await this.#koniState.validateCustomAsset(data);
   }
-  async getAddressFreeBalance(_ref47) {
+  async getAddressFreeBalance(_ref48) {
     let {
       address,
       networkKey,
       token
-    } = _ref47;
+    } = _ref48;
     if (token && _constants2._MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
       const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
       if (tokenInfo.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
@@ -1918,14 +1939,14 @@ class KoniExtension {
     }
     return await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
   }
-  async transferGetMaxTransferable(_ref48) {
+  async transferGetMaxTransferable(_ref49) {
     let {
       address,
       destChain,
       isXcmTransfer,
       networkKey,
       token
-    } = _ref48;
+    } = _ref49;
     const freeBalance = await this.getAddressFreeBalance({
       address,
       networkKey,
@@ -2009,12 +2030,12 @@ class KoniExtension {
       };
     }
   }
-  async subscribeAddressFreeBalance(_ref49, id, port) {
+  async subscribeAddressFreeBalance(_ref50, id, port) {
     let {
       address,
       networkKey,
       token
-    } = _ref49;
+    } = _ref50;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const convertData = data => {
       return {
@@ -2033,26 +2054,26 @@ class KoniExtension {
     });
     return convertData(currentFreeBalance);
   }
-  async transferCheckReferenceCount(_ref50) {
+  async transferCheckReferenceCount(_ref51) {
     let {
       address,
       networkKey
-    } = _ref50;
+    } = _ref51;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
     return await (0, _transfer.checkReferenceCount)(networkKey, address, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
   }
-  async transferCheckSupporting(_ref51) {
+  async transferCheckSupporting(_ref52) {
     let {
       networkKey,
       tokenSlug
-    } = _ref51;
+    } = _ref52;
     const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
     return await (0, _transfer.checkSupportTransfer)(networkKey, tokenInfo, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
   }
-  transferGetExistentialDeposit(_ref52) {
+  transferGetExistentialDeposit(_ref53) {
     let {
       tokenSlug
-    } = _ref52;
+    } = _ref53;
     const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
     return (0, _utils2._getTokenMinAmount)(tokenInfo);
   }
@@ -2088,11 +2109,11 @@ class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(_ref53) {
+  async enableChains(_ref54) {
     let {
       chainSlugs,
       enableTokens
-    } = _ref53;
+    } = _ref54;
     try {
       await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
         chainSlug,
@@ -2103,24 +2124,24 @@ class KoniExtension {
     }
     return true;
   }
-  getAccountMeta(_ref54) {
+  getAccountMeta(_ref55) {
     let {
       address
-    } = _ref54;
+    } = _ref55;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
     return {
       meta: pair.meta
     };
   }
-  accountsTie2(_ref55) {
+  accountsTie2(_ref56) {
     let {
       address,
       genesisHash
-    } = _ref55;
+    } = _ref56;
     return this.#koniState.setAccountTie(address, genesisHash);
   }
-  async accountsCreateExternalV2(_ref56) {
+  async accountsCreateExternalV2(_ref57) {
     let {
       address,
       genesisHash,
@@ -2128,7 +2149,7 @@ class KoniExtension {
       isEthereum,
       isReadOnly,
       name
-    } = _ref56;
+    } = _ref57;
     try {
       let result;
       try {
@@ -2187,7 +2208,7 @@ class KoniExtension {
       }];
     }
   }
-  async accountsCreateHardwareV2(_ref57) {
+  async accountsCreateHardwareV2(_ref58) {
     let {
       accountIndex,
       address,
@@ -2196,7 +2217,7 @@ class KoniExtension {
       hardwareType,
       isAllowed,
       name
-    } = _ref57;
+    } = _ref58;
     const key = _uiKeyring.keyring.addHardware(address, hardwareType, {
       accountIndex,
       addressOffset,
@@ -2219,10 +2240,10 @@ class KoniExtension {
     });
     return true;
   }
-  async accountsCreateHardwareMultiple(_ref58) {
+  async accountsCreateHardwareMultiple(_ref59) {
     let {
       accounts
-    } = _ref58;
+    } = _ref59;
     const addresses = [];
     if (!accounts.length) {
       throw new Error((0, _i18next.t)("Can't find an account. Please try again"));
@@ -2300,14 +2321,14 @@ class KoniExtension {
     }
     return true;
   }
-  async accountsCreateWithSecret(_ref59) {
+  async accountsCreateWithSecret(_ref60) {
     let {
       isAllow,
       isEthereum,
       name,
       publicKey,
       secretKey
-    } = _ref59;
+    } = _ref60;
     try {
       let keyringPair = null;
       if (isEthereum) {
@@ -2453,30 +2474,30 @@ class KoniExtension {
 
   // Parse transaction
 
-  parseSubstrateTransaction(_ref60) {
+  parseSubstrateTransaction(_ref61) {
     let {
       data,
       networkKey
-    } = _ref60;
+    } = _ref61;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
     const apiPromise = apiProps.api;
     return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
   }
-  async parseEVMRLP(_ref61) {
+  async parseEVMRLP(_ref62) {
     let {
       data
-    } = _ref61;
+    } = _ref62;
     return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
   }
 
   // Sign
 
-  qrSignSubstrate(_ref62) {
+  qrSignSubstrate(_ref63) {
     let {
       address,
       data,
       networkKey
-    } = _ref62;
+    } = _ref63;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
     if (pair.isLocked) {
@@ -2493,13 +2514,13 @@ class KoniExtension {
       signature: signed
     };
   }
-  async qrSignEVM(_ref63) {
+  async qrSignEVM(_ref64) {
     let {
       address,
       chainId,
       message,
       type
-    } = _ref63;
+    } = _ref64;
     let signed;
     const network = this.getNetworkJsonByChainId(chainId);
     if (!network) {
@@ -2583,11 +2604,11 @@ class KoniExtension {
     });
     return this.#koniState.getNominatorMetadata();
   }
-  async getBondingOptions(_ref64) {
+  async getBondingOptions(_ref65) {
     let {
       chain,
       type
-    } = _ref64;
+    } = _ref65;
     const apiProps = this.#koniState.getSubstrateApi(chain);
     const chainInfo = this.#koniState.getChainInfo(chain);
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
@@ -2777,12 +2798,12 @@ class KoniExtension {
   }
 
   // EVM Transaction
-  async parseContractInput(_ref65) {
+  async parseContractInput(_ref66) {
     let {
       chainId,
       contract,
       data
-    } = _ref65;
+    } = _ref66;
     const network = this.getNetworkJsonByChainId(chainId);
     return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
   }
@@ -2853,12 +2874,12 @@ class KoniExtension {
 
   // Change master password
 
-  keyringChangeMasterPassword(_ref66) {
+  keyringChangeMasterPassword(_ref67) {
     let {
       createNew,
       newPassword,
       oldPassword
-    } = _ref66;
+    } = _ref67;
     try {
       // Remove isMasterPassword meta if createNew
       if (createNew && !_uiKeyring.keyring.keyring.hasMasterPassword) {
@@ -2908,11 +2929,11 @@ class KoniExtension {
       }
     }
   }
-  keyringMigrateMasterPassword(_ref67) {
+  keyringMigrateMasterPassword(_ref68) {
     let {
       address,
       password
-    } = _ref67;
+    } = _ref68;
     try {
       _uiKeyring.keyring.migrateWithMasterPassword(address, password);
       this.checkLockAfterMigrate();
@@ -2931,10 +2952,10 @@ class KoniExtension {
 
   // Unlock wallet
 
-  keyringUnlock(_ref68) {
+  keyringUnlock(_ref69) {
     let {
       password
-    } = _ref68;
+    } = _ref69;
     try {
       _uiKeyring.keyring.unlockKeyring(password);
       this.#koniState.initMantaPay(password).catch(console.error);
@@ -2960,11 +2981,11 @@ class KoniExtension {
 
   // Export mnemonic
 
-  keyringExportMnemonic(_ref69) {
+  keyringExportMnemonic(_ref70) {
     let {
       address,
       password
-    } = _ref69;
+    } = _ref70;
     const pair = _uiKeyring.keyring.getPair(address);
     const result = pair.exportMnemonic(password);
     return {
@@ -2974,10 +2995,10 @@ class KoniExtension {
 
   // Reset wallet
 
-  async resetWallet(_ref70) {
+  async resetWallet(_ref71) {
     let {
       resetAll
-    } = _ref70;
+    } = _ref71;
     try {
       await this.#koniState.resetWallet(resetAll);
       return {
@@ -2993,10 +3014,10 @@ class KoniExtension {
   }
 
   /// Signing substrate request
-  signingApprovePasswordV2(_ref71) {
+  signingApprovePasswordV2(_ref72) {
     let {
       id
-    } = _ref71;
+    } = _ref72;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -3061,22 +3082,22 @@ class KoniExtension {
 
   /// Derive account
 
-  derivationCreateMultiple(_ref72) {
+  derivationCreateMultiple(_ref73) {
     let {
       isAllowed,
       items,
       parentAddress
-    } = _ref72;
+    } = _ref73;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
       _uiKeyring.keyring.unlockPair(parentPair.address);
     }
-    const createChild = _ref73 => {
+    const createChild = _ref74 => {
       let {
         name,
         suri
-      } = _ref73;
+      } = _ref74;
       const meta = {
         name: name,
         parentAddress
@@ -3122,10 +3143,10 @@ class KoniExtension {
     }
     return true;
   }
-  derivationCreateV3(_ref74) {
+  derivationCreateV3(_ref75) {
     let {
       address: parentAddress
-    } = _ref74;
+    } = _ref75;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -3160,11 +3181,11 @@ class KoniExtension {
     }
     return true;
   }
-  validateDerivePath(_ref75) {
+  validateDerivePath(_ref76) {
     let {
       parentAddress,
       suri
-    } = _ref75;
+    } = _ref76;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -3197,12 +3218,12 @@ class KoniExtension {
       suri: meta.suri
     };
   }
-  getListDeriveAccounts(_ref76) {
+  getListDeriveAccounts(_ref77) {
     let {
       limit,
       page,
       parentAddress
-    } = _ref76;
+    } = _ref77;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -3312,10 +3333,10 @@ class KoniExtension {
   getSupportedSmartContractTypes() {
     return this.#koniState.getSupportedSmartContractTypes();
   }
-  getTransaction(_ref77) {
+  getTransaction(_ref78) {
     let {
       id
-    } = _ref77;
+    } = _ref78;
     const {
       transaction,
       ...transactionResult
@@ -3325,8 +3346,8 @@ class KoniExtension {
   subscribeTransactions(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     function convertRs(rs) {
-      return Object.fromEntries(Object.entries(rs).map(_ref78 => {
-        let [key, value] = _ref78;
+      return Object.fromEntries(Object.entries(rs).map(_ref79 => {
+        let [key, value] = _ref79;
         const {
           additionalValidator,
           eventsHandler,
@@ -3358,10 +3379,10 @@ class KoniExtension {
     });
     return notificationSubject.value;
   }
-  async reloadCron(_ref79) {
+  async reloadCron(_ref80) {
     let {
       data
-    } = _ref79;
+    } = _ref80;
     if (data === 'nft') {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
@@ -3405,20 +3426,20 @@ class KoniExtension {
 
   // Phishing detect
 
-  async passPhishingPage(_ref80) {
+  async passPhishingPage(_ref81) {
     let {
       url
-    } = _ref80;
+    } = _ref81;
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
   /// Wallet connect
 
   // Connect
-  async connectWalletConnect(_ref81) {
+  async connectWalletConnect(_ref82) {
     let {
       uri
-    } = _ref81;
+    } = _ref82;
     await this.#koniState.walletConnectService.connect(uri);
     return true;
   }
@@ -3431,11 +3452,11 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allConnectWCRequests;
   }
-  async approveWalletConnectSession(_ref82) {
+  async approveWalletConnectSession(_ref83) {
     let {
       accounts: selectedAccounts,
       id
-    } = _ref82;
+    } = _ref83;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
       throw new Error('The proposal has been expired');
@@ -3447,8 +3468,8 @@ class KoniExtension {
     const availableNamespaces = {};
     const namespaces = {};
     const chainInfoMap = this.#koniState.getChainInfoMap();
-    Object.entries(requiredNamespaces).forEach(_ref83 => {
-      let [key, namespace] = _ref83;
+    Object.entries(requiredNamespaces).forEach(_ref84 => {
+      let [key, namespace] = _ref84;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
@@ -3461,8 +3482,8 @@ class KoniExtension {
         throw new Error((0, _utils5.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
-    Object.entries(optionalNamespaces).forEach(_ref84 => {
-      let [key, namespace] = _ref84;
+    Object.entries(optionalNamespaces).forEach(_ref85 => {
+      let [key, namespace] = _ref85;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const supportChains = namespace.chains.filter(chain => (0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap)) || [];
@@ -3486,8 +3507,8 @@ class KoniExtension {
         }
       }
     });
-    Object.entries(availableNamespaces).forEach(_ref85 => {
-      let [key, namespace] = _ref85;
+    Object.entries(availableNamespaces).forEach(_ref86 => {
+      let [key, namespace] = _ref86;
       if (namespace.chains) {
         const accounts = [];
         const chains = (0, _utils4.uniqueStringArray)(namespace.chains);
@@ -3511,10 +3532,10 @@ class KoniExtension {
     request.resolve();
     return true;
   }
-  async rejectWalletConnectSession(_ref86) {
+  async rejectWalletConnectSession(_ref87) {
     let {
       id
-    } = _ref86;
+    } = _ref87;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     const wcId = request.request.id;
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
@@ -3536,10 +3557,10 @@ class KoniExtension {
     });
     return this.#koniState.walletConnectService.sessions;
   }
-  async disconnectWalletConnectSession(_ref87) {
+  async disconnectWalletConnectSession(_ref88) {
     let {
       topic
-    } = _ref87;
+    } = _ref88;
     await this.#koniState.walletConnectService.disconnect(topic);
     return true;
   }
@@ -3552,18 +3573,18 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allNotSupportWCRequests;
   }
-  approveWalletConnectNotSupport(_ref88) {
+  approveWalletConnectNotSupport(_ref89) {
     let {
       id
-    } = _ref88;
+    } = _ref89;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.resolve();
     return true;
   }
-  rejectWalletConnectNotSupport(_ref89) {
+  rejectWalletConnectNotSupport(_ref90) {
     let {
       id
-    } = _ref89;
+    } = _ref90;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.reject(new Error('USER_REJECTED'));
     return true;
@@ -3571,11 +3592,11 @@ class KoniExtension {
 
   /// Manta
 
-  async enableMantaPay(_ref90) {
+  async enableMantaPay(_ref91) {
     let {
       address,
       password
-    } = _ref90;
+    } = _ref91;
     // always takes the current account
     function timeout() {
       return new Promise(resolve => setTimeout(resolve, 1500));
@@ -3699,10 +3720,10 @@ class KoniExtension {
 
   /// Metadata
 
-  async findRawMetadata(_ref91) {
+  async findRawMetadata(_ref92) {
     let {
       genesisHash
-    } = _ref91;
+    } = _ref92;
     const {
       metadata,
       specVersion
@@ -3949,18 +3970,18 @@ class KoniExtension {
 
   /* Campaign */
 
-  unlockDotCheckCanMint(_ref92) {
+  unlockDotCheckCanMint(_ref93) {
     let {
       address,
       network,
       slug
-    } = _ref92;
+    } = _ref93;
     return this.#koniState.mintCampaignService.unlockDotCampaign.canMint(address, slug, network);
   }
-  unlockDotSubscribeMintedData(id, port, _ref93) {
+  unlockDotSubscribeMintedData(id, port, _ref94) {
     let {
       transactionId
-    } = _ref93;
+    } = _ref94;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscription = this.#koniState.mintCampaignService.unlockDotCampaign.subscribeMintedNft(transactionId, cb);
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
@@ -3992,10 +4013,10 @@ class KoniExtension {
     });
     return filterBanner(await this.#koniState.campaignService.getProcessingCampaign());
   }
-  async completeCampaignBanner(_ref94) {
+  async completeCampaignBanner(_ref95) {
     let {
       slug
-    } = _ref94;
+    } = _ref95;
     const campaign = await this.#koniState.dbService.getCampaign(slug);
     if (campaign) {
       await this.#koniState.dbService.upsertCampaign({
@@ -4047,6 +4068,82 @@ class KoniExtension {
 
   /* Buy service */
 
+  /* Swap service */
+  async subscribeSwapPairs(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    let ready = false;
+    await this.#koniState.swapService.waitForStarted();
+    const callback = rs => {
+      if (ready) {
+        cb(rs);
+      }
+    };
+    const subscription = this.#koniState.swapService.subscribeSwapPairs(callback);
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    ready = true;
+    return this.#koniState.swapService.getSwapPairs();
+  }
+  async handleSwapRequest(request) {
+    return this.#koniState.swapService.handleSwapRequest(request);
+  }
+  async getLatestSwapQuote(swapRequest) {
+    return this.#koniState.swapService.getLatestQuotes(swapRequest);
+  }
+  async validateSwapProcess(params) {
+    return this.#koniState.swapService.validateSwapProcess(params);
+  }
+  async handleSwapStep(inputData) {
+    const {
+      address,
+      process,
+      quote,
+      recipient
+    } = inputData;
+    if (!quote || !address || !process) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const isLastStep = inputData.currentStep + 1 === process.steps.length;
+    const swapValidations = await this.#koniState.swapService.validateSwapProcess({
+      address,
+      process,
+      selectedQuote: quote,
+      recipient
+    });
+    if (swapValidations.length > 0) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors(swapValidations);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const {
+      chainType,
+      extrinsic,
+      extrinsicType,
+      transferNativeAmount,
+      txChain,
+      txData
+    } = await this.#koniState.swapService.handleSwapProcess(inputData);
+    // const chosenFeeToken = process.steps.findIndex((step) => step.type === SwapStepType.SET_FEE_TOKEN) > -1;
+    // const allowSkipValidation = [ExtrinsicType.SET_FEE_TOKEN, ExtrinsicType.SWAP].includes(extrinsicType);
+
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: txChain,
+      transaction: extrinsic,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      data: txData,
+      extrinsicType,
+      // change this depends on step
+      chainType,
+      resolveOnDone: !isLastStep,
+      transferNativeAmount
+      // skipFeeValidation: chosenFeeToken && allowSkipValidation
+    });
+  }
+  /* Swap service */
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -4178,6 +4275,8 @@ class KoniExtension {
         return this.subscribeCrowdloan(id, port);
       case 'pri(derivation.createV2)':
         return this.derivationCreateV2(request);
+      case 'pri(accounts.batchExportV2)':
+        return this.batchExportV2(request);
       case 'pri(json.restoreV2)':
         return this.jsonRestoreV2(request);
       case 'pri(json.batchRestoreV2)':
@@ -4576,6 +4675,19 @@ class KoniExtension {
       case 'pri(database.exportJson)':
         return this.#koniState.dbService.getExportJson();
       /* Database */
+
+      /* Swap service */
+      case 'pri(swapService.subscribePairs)':
+        return this.subscribeSwapPairs(id, port);
+      case 'pri(swapService.handleSwapRequest)':
+        return this.handleSwapRequest(request);
+      case 'pri(swapService.getLatestQuote)':
+        return this.getLatestSwapQuote(request);
+      case 'pri(swapService.validateSwapProcess)':
+        return this.validateSwapProcess(request);
+      case 'pri(swapService.handleSwapStep)':
+        return this.handleSwapStep(request);
+      /* Swap service */
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);