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

package/cjs/utils/swap.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.swapCustomFormatter = exports.formatNumberString = void 0;
+var _number = require("@subwallet/extension-base/utils/number");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Clear zero from end, use with decimal only
+const clearZero = result => {
+  let index = result.length - 1;
+  while (result[index] === '0') {
+    result = result.slice(0, index);
+    index--;
+  }
+  return result;
+};
+const NUM_1T = new _bignumber.default(1e12);
+const TLIM = new _bignumber.default(1e17);
+const NUM_1B = new _bignumber.default(1e9);
+const BLIM = new _bignumber.default(1e14);
+const NUM_1M = new _bignumber.default(1e6);
+const NUM_100M = new _bignumber.default(1e8);
+const swapCustomFormatter = (input, metadata) => {
+  const minNumberFormat = 2;
+  const maxNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat) || 6;
+  const [int, decimal = '0'] = input.split('.');
+  let _decimal = '';
+  const intNumber = new _bignumber.default(int);
+  const max = _number.BN_TEN.pow(maxNumberFormat);
+
+  // If count of number in integer part greater or equal maxNumberFormat, do not show decimal
+  if (intNumber.gte(max)) {
+    if (intNumber.gte(NUM_100M)) {
+      if (intNumber.gte(BLIM)) {
+        if (intNumber.gte(TLIM)) {
+          return `${intNumber.dividedBy(NUM_1T).toFixed()} T`;
+        }
+        return `${intNumber.dividedBy(NUM_1B).toFixed()} B`;
+      }
+      return `${intNumber.dividedBy(NUM_1M).toFixed()} M`;
+    }
+    _decimal = decimal.slice(0, metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat);
+    return `${int}.${_decimal}`;
+  }
+
+  // Get only minNumberFormat number at decimal
+  if (decimal.length <= minNumberFormat || !(metadata !== null && metadata !== void 0 && metadata.maxNumberFormat)) {
+    _decimal = decimal;
+  } else {
+    _decimal = decimal.slice(0, maxNumberFormat);
+  }
+
+  // Clear zero number for decimal
+  _decimal = clearZero(_decimal);
+  if (_decimal) {
+    return `${int}.${_decimal}`;
+  }
+  return int;
+};
+exports.swapCustomFormatter = swapCustomFormatter;
+const formatNumberString = numberString => {
+  const number = parseFloat(numberString);
+  const exponentNotation = number.toExponential();
+  let [coefficient, exponent] = exponentNotation.split('e');
+  if (parseInt(exponent) < 0) {
+    coefficient = coefficient.replace(/^0+|\./g, '');
+    coefficient = '0.' + '0'.repeat(Math.abs(parseInt(exponent)) - 1) + coefficient;
+  } else {
+    coefficient += '0'.repeat(parseInt(exponent) - coefficient.length + 1);
+  }
+  return coefficient;
+};
+exports.formatNumberString = formatNumberString;

package/koni/api/nft/{statemint_nft → assethub_nft}/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-export default class StatemintNftApi extends BaseNftApi {
+export default class AssetHubNftsPalletApi extends BaseNftApi {
     constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
     private getMetadata;
     /**

package/koni/api/nft/{statemint_nft → assethub_nft}/index.js

@@ -1,10 +1,11 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { AssetHubNftType } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
 import { isUrl } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
-export default class StatemintNftApi extends BaseNftApi {
+export default class AssetHubNftsPalletApi extends BaseNftApi {
   // eslint-disable-next-line no-useless-constructor
   constructor(api, addresses, chain) {
     super(chain, api, addresses);
@@ -105,7 +106,8 @@ export default class StatemintNftApi extends BaseNftApi {
           image: tokenInfo && tokenInfo.image ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image) : undefined,
           collectionId: this.parseTokenId(parsedClassId),
           chain: this.chain,
-          owner: address
+          owner: address,
+          assetHubType: AssetHubNftType.NFTS
         };
         params.updateItem(this.chain, parsedNft, address);
         const parsedCollection = {

package/koni/api/nft/{statemine_nft → assethub_unique}/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-export default class StatemineNftApi extends BaseNftApi {
+export default class AssetHubUniquesPalletApi extends BaseNftApi {
     constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
     private getMetadata;
     /**

package/koni/api/nft/{statemine_nft → assethub_unique}/index.js

@@ -1,10 +1,11 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { AssetHubNftType } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
 import { isUrl } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
-export default class StatemineNftApi extends BaseNftApi {
+export default class AssetHubUniquesPalletApi extends BaseNftApi {
   // eslint-disable-next-line no-useless-constructor
   constructor(api, addresses, chain) {
     super(chain, api, addresses);
@@ -105,7 +106,8 @@ export default class StatemineNftApi extends BaseNftApi {
           image: tokenInfo && tokenInfo.image ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image) : undefined,
           collectionId: this.parseTokenId(parsedClassId),
           chain: this.chain,
-          owner: address
+          owner: address,
+          assetHubType: AssetHubNftType.UNIQUES
         };
         params.updateItem(this.chain, parsedNft, address);
         const parsedCollection = {

package/koni/api/nft/index.js

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AcalaNftApi } from '@subwallet/extension-base/koni/api/nft/acala_nft';
+import AssetHubUniquesPalletApi from '@subwallet/extension-base/koni/api/nft/assethub_unique';
 import { BitCountryNftApi } from '@subwallet/extension-base/koni/api/nft/bit.country';
 import { EvmNftApi } from '@subwallet/extension-base/koni/api/nft/evm_nft';
 import { KaruraNftApi } from '@subwallet/extension-base/koni/api/nft/karura_nft';
 import OrdinalNftApi from '@subwallet/extension-base/koni/api/nft/ordinal_nft';
 import { RmrkNftApi } from '@subwallet/extension-base/koni/api/nft/rmrk_nft';
-import StatemineNftApi from '@subwallet/extension-base/koni/api/nft/statemine_nft';
 import { UniqueNftApi } from '@subwallet/extension-base/koni/api/nft/unique_network_nft';
 // import UniqueNftApi from '@subwallet/extension-base/koni/api/nft/unique_nft';
 import { VaraNftApi } from '@subwallet/extension-base/koni/api/nft/vara_nft';
@@ -15,25 +15,25 @@ import { WasmNftApi } from '@subwallet/extension-base/koni/api/nft/wasm_nft';
 import { _NFT_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft, _isSupportOrdinal } from '@subwallet/extension-base/services/chain-service/utils';
 import { categoryAddresses, targetIsWeb } from '@subwallet/extension-base/utils';
-import StatemintNftApi from "./statemint_nft/index.js";
+import AssetHubNftsPalletApi from "./assethub_nft/index.js";
 function createSubstrateNftApi(chain, substrateApi, addresses) {
   const [substrateAddresses] = categoryAddresses(addresses);
   if (_NFT_CHAIN_GROUP.acala.includes(chain)) {
-    return new AcalaNftApi(substrateApi, substrateAddresses, chain);
+    return [new AcalaNftApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.karura.includes(chain)) {
-    return new KaruraNftApi(substrateApi, substrateAddresses, chain);
+    return [new KaruraNftApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.rmrk.includes(chain)) {
-    return new RmrkNftApi(substrateAddresses, chain);
+    return [new RmrkNftApi(substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.statemine.includes(chain)) {
-    return new StatemineNftApi(substrateApi, substrateAddresses, chain);
+    return [new AssetHubUniquesPalletApi(substrateApi, substrateAddresses, chain), new AssetHubNftsPalletApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.statemint.includes(chain)) {
-    return new StatemintNftApi(substrateApi, substrateAddresses, chain);
+    return [new AssetHubUniquesPalletApi(substrateApi, substrateAddresses, chain), new AssetHubNftsPalletApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.unique_network.includes(chain)) {
-    return new UniqueNftApi(chain, substrateAddresses);
+    return [new UniqueNftApi(chain, substrateAddresses)];
   } else if (_NFT_CHAIN_GROUP.bitcountry.includes(chain)) {
-    return new BitCountryNftApi(substrateApi, substrateAddresses, chain);
+    return [new BitCountryNftApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.vara.includes(chain)) {
-    return new VaraNftApi(chain, substrateAddresses);
+    return [new VaraNftApi(chain, substrateAddresses)];
   }
   return null;
 }
@@ -105,9 +105,9 @@ export class NftHandler {
         Object.entries(this.chainInfoMap).forEach(([chain, chainInfo]) => {
           if (_isChainSupportNativeNft(chainInfo)) {
             if (this.substrateApiMap[chain]) {
-              const handler = createSubstrateNftApi(chain, this.substrateApiMap[chain], substrateAddresses);
-              if (handler) {
-                this.handlers.push(handler);
+              const handlers = createSubstrateNftApi(chain, this.substrateApiMap[chain], substrateAddresses);
+              if (handlers && !!handlers.length) {
+                this.handlers.push(...handlers);
               }
             }
           }

package/koni/api/nft/nft.js

@@ -59,7 +59,7 @@ export class BaseNftApi {
   }
   parseTokenId(tokenId) {
     if (tokenId.includes(',')) {
-      return tokenId.replace(',', '');
+      return tokenId.replaceAll(',', '');
     }
     return tokenId;
   }

package/koni/api/nft/transfer.d.ts

@@ -3,6 +3,5 @@ export declare function isRecipientSelf(currentAddress: string, recipientAddress
 export declare function acalaGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
 export declare function rmrkGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
 export declare function uniqueGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;
-export declare function statemineGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
-export declare function statemintGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function assetHubGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
 export declare function getNftTransferExtrinsic(networkKey: string, substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;

package/koni/api/nft/transfer.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { AssetHubNftType } from '@subwallet/extension-base/background/KoniTypes';
 import { SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME } from '@subwallet/extension-base/koni/api/nft/config';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 export function isRecipientSelf(currentAddress, recipientAddress) {
@@ -52,21 +53,17 @@ export async function uniqueGetExtrinsic(substrateApi, senderAddress, recipientA
     return null;
   }
 }
-export function statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+export function assetHubGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
   try {
     const itemId = params.itemId;
     const collectionId = params.collectionId;
-    return substrateApi.api.tx.uniques.transfer(collectionId, itemId, recipientAddress);
-  } catch (e) {
-    console.error(e);
+    const nftType = params.assetHubType;
+    if (nftType === AssetHubNftType.NFTS) {
+      return substrateApi.api.tx.nfts.transfer(collectionId, itemId, recipientAddress);
+    } else if (nftType === AssetHubNftType.UNIQUES) {
+      return substrateApi.api.tx.uniques.transfer(collectionId, itemId, recipientAddress);
+    }
     return null;
-  }
-}
-export function statemintGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
-  try {
-    const itemId = params.itemId;
-    const collectionId = params.collectionId;
-    return substrateApi.api.tx.nfts.transfer(collectionId, itemId, recipientAddress);
   } catch (e) {
     console.error(e);
     return null;
@@ -87,9 +84,9 @@ export async function getNftTransferExtrinsic(networkKey, substrateApi, senderAd
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.opal:
       return await uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemine:
-      return statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+      return assetHubGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemint:
-      return statemintGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+      return assetHubGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.bitcountry:
       return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.pioneer:

package/koni/api/staking/bonding/utils.d.ts

@@ -1,7 +1,7 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { NominationInfo, NominatorMetadata, StakingType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
 import { _SubstrateInflationParams } from '@subwallet/extension-base/services/chain-service/constants';
-import { EarningStatus, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
+import { EarningStatus, PalletStakingEraRewardPoints, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
 import BigNumber from 'bignumber.js';
 import { ApiPromise } from '@polkadot/api';
 import { Codec } from '@polkadot/types/types';
@@ -158,6 +158,8 @@ export declare function getEarningStatusByNominations(bnTotalActiveStake: BN, no
 export declare function getValidatorLabel(chain: string): "dApp" | "Validator" | "Collator";
 export declare function getAvgValidatorEraReward(supportedDays: number, eraRewardHistory: Codec[]): BigNumber;
 export declare function getSupportedDaysByHistoryDepth(erasPerDay: number, maxSupportedEras: number): 15 | 30;
+export declare function getValidatorPointsMap(eraRewardMap: Record<string, PalletStakingEraRewardPoints>): Record<string, BigNumber>;
+export declare function getTopValidatorByPoints(validatorPointsList: Record<string, BigNumber>): string[];
 export declare const getMinStakeErrorMessage: (chainInfo: _ChainInfo, bnMinStake: BN) => string;
 export declare const getMaxValidatorErrorMessage: (chainInfo: _ChainInfo, max: number) => string;
 export declare const getExistUnstakeErrorMessage: (chain: string, type?: StakingType, isStakeMore?: boolean) => string;

package/koni/api/staking/bonding/utils.js

@@ -197,13 +197,13 @@ export function getYieldAvailableActionsByPosition(yieldPosition, yieldPoolInfo,
   const result = [];
   if ([YieldPoolType.NATIVE_STAKING, YieldPoolType.NOMINATION_POOL].includes(yieldPoolInfo.type)) {
     result.push(YieldAction.STAKE);
-    const bnActiveStake = new BN(yieldPosition.activeStake);
-    if (yieldPosition.activeStake && bnActiveStake.gt(BN_ZERO)) {
+    const bnActiveStake = new BigNumber(yieldPosition.activeStake);
+    if (yieldPosition.activeStake && bnActiveStake.gt('0')) {
       result.push(YieldAction.UNSTAKE);
       const isAstarNetwork = _STAKING_CHAIN_GROUP.astar.includes(yieldPosition.chain);
       const isAmplitudeNetwork = _STAKING_CHAIN_GROUP.amplitude.includes(yieldPosition.chain);
-      const bnUnclaimedReward = new BN(unclaimedReward || '0');
-      if ((yieldPosition.type === YieldPoolType.NOMINATION_POOL || isAmplitudeNetwork) && bnUnclaimedReward.gt(BN_ZERO) || isAstarNetwork) {
+      const bnUnclaimedReward = new BigNumber(unclaimedReward || '0');
+      if ((yieldPosition.type === YieldPoolType.NOMINATION_POOL || isAmplitudeNetwork) && bnUnclaimedReward.gt('0') || isAstarNetwork) {
         result.push(YieldAction.CLAIM_REWARD);
       }
     }
@@ -216,8 +216,8 @@ export function getYieldAvailableActionsByPosition(yieldPosition, yieldPoolInfo,
     }
   } else if (yieldPoolInfo.type === YieldPoolType.LIQUID_STAKING) {
     result.push(YieldAction.START_EARNING);
-    const activeBalance = new BN(yieldPosition.activeStake || '0');
-    if (activeBalance.gt(BN_ZERO)) {
+    const activeBalance = new BigNumber(yieldPosition.activeStake);
+    if (activeBalance.gt('0')) {
       result.push(YieldAction.UNSTAKE);
     }
     const hasWithdrawal = yieldPosition.unstakings.some(unstakingInfo => unstakingInfo.status === UnstakingStatus.CLAIMABLE);
@@ -350,6 +350,32 @@ export function getSupportedDaysByHistoryDepth(erasPerDay, maxSupportedEras) {
     return 15;
   }
 }
+export function getValidatorPointsMap(eraRewardMap) {
+  // mapping store validator and totalPoints
+  const validatorTotalPointsMap = {};
+  Object.values(eraRewardMap).forEach(info => {
+    const individual = info.individual;
+    Object.entries(individual).forEach(([validator, rawPoints]) => {
+      const points = rawPoints.replaceAll(',', '');
+      if (!validatorTotalPointsMap[validator]) {
+        validatorTotalPointsMap[validator] = new BigNumber(points);
+      } else {
+        validatorTotalPointsMap[validator] = validatorTotalPointsMap[validator].plus(points);
+      }
+    });
+  });
+  return validatorTotalPointsMap;
+}
+export function getTopValidatorByPoints(validatorPointsList) {
+  const sortValidatorPointsList = Object.fromEntries(Object.entries(validatorPointsList).sort((a, b) => a[1].minus(b[1]).toNumber()).reverse());
+
+  // keep 50% first validator
+  const entries = Object.entries(sortValidatorPointsList);
+  const endIndex = Math.ceil(entries.length / 2);
+  const top50PercentEntries = entries.slice(0, endIndex);
+  const top50PercentRecord = Object.fromEntries(top50PercentEntries);
+  return Object.keys(top50PercentRecord);
+}
 export const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = _getChainNativeTokenBasicInfo(chainInfo);
   const number = formatNumber(bnMinStake.toString(), tokenInfo.decimals || 0, balanceFormatter);

package/koni/background/handlers/Extension.d.ts

@@ -108,6 +108,7 @@ export default class KoniExtension {
     private derivationCreateV2;
     private jsonRestoreV2;
     private batchRestoreV2;
+    private batchExportV2;
     private getNftCollection;
     private subscribeNftCollection;
     private getNft;
@@ -237,5 +238,10 @@ export default class KoniExtension {
     private completeCampaignBanner;
     private subscribeBuyTokens;
     private subscribeBuyServices;
+    private subscribeSwapPairs;
+    private handleSwapRequest;
+    private getLatestSwapQuote;
+    private validateSwapProcess;
+    private handleSwapStep;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
 }

package/koni/background/handlers/Extension.js

@@ -1393,6 +1393,26 @@ export default class KoniExtension {
       throw new Error(t('Wrong password'));
     }
   }
+  async batchExportV2({
+    addresses,
+    password
+  }) {
+    try {
+      if (addresses && !addresses.length) {
+        throw new Error(t('No accounts found to export'));
+      }
+      return {
+        exportedJson: await keyring.backupAccounts(password, addresses)
+      };
+    } catch (e) {
+      const error = e;
+      if (error.message === 'Invalid master password') {
+        throw new Error(t('Wrong password'));
+      } else {
+        throw error;
+      }
+    }
+  }
   getNftCollection() {
     return this.#koniState.getNftCollection();
   }
@@ -3943,6 +3963,82 @@ export default class KoniExtension {
 
   /* Buy service */
 
+  /* Swap service */
+  async subscribeSwapPairs(id, port) {
+    const cb = 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(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) {
@@ -4074,6 +4170,8 @@ export default 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)':
@@ -4472,6 +4570,19 @@ export default 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}`);

package/koni/background/handlers/State.d.ts

@@ -21,6 +21,7 @@ import { AuthUrls, MetaRequest, SignRequest } from '@subwallet/extension-base/se
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
+import { SwapService } from '@subwallet/extension-base/services/swap-service';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import { BalanceMap, EvmFeeInfo } from '@subwallet/extension-base/types';
@@ -71,6 +72,7 @@ export default class KoniState {
     readonly buyService: BuyService;
     readonly earningService: EarningService;
     readonly feeService: FeeService;
+    readonly swapService: SwapService;
     private generalStatus;
     private waitSleeping;
     private waitStarting;

package/koni/background/handlers/State.js

@@ -28,6 +28,7 @@ import SettingService from '@subwallet/extension-base/services/setting-service/S
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
 import { SUBSCAN_API_CHAIN_MAP } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import { SwapService } from '@subwallet/extension-base/services/swap-service';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
@@ -104,6 +105,7 @@ export default class KoniState {
     this.transactionService = new TransactionService(this);
     this.earningService = new EarningService(this);
     this.feeService = new FeeService(this);
+    this.swapService = new SwapService(this);
     this.subscription = new KoniSubscription(this, this.dbService);
     this.cron = new KoniCron(this, this.subscription, this.dbService);
     this.logger = createLogger('State');
@@ -226,6 +228,7 @@ export default class KoniState {
     this.eventService.emit('chain.ready', true);
     await this.balanceService.init();
     await this.earningService.init();
+    await this.swapService.init();
     this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
@@ -1396,7 +1399,7 @@ export default class KoniState {
     // Stopping services
     await Promise.all([this.cron.stop(), this.subscription.stop()]);
     await this.pauseAllNetworks(undefined, 'IDLE mode');
-    await Promise.all([this.historyService.stop(), this.priceService.stop(), this.balanceService.stop(), this.earningService.stop()]);
+    await Promise.all([this.historyService.stop(), this.priceService.stop(), this.balanceService.stop(), this.earningService.stop(), this.swapService.stop()]);
 
     // Complete sleeping
     sleeping.resolve();
@@ -1428,7 +1431,7 @@ export default class KoniState {
     }
 
     // Start services
-    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start()]);
+    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start(), this.swapService.start()]);
 
     // Complete starting
     starting.resolve();