@subwallet/extension-base 1.1.53-0 → 1.1.53-beta.0

package/cjs/services/swap-service/utils.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SWAP_QUOTE_TIMEOUT_MAP = exports.MOCK_SWAP_FEE = exports.DEFAULT_SWAP_FIRST_STEP = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
+exports.calculateSwapRate = calculateSwapRate;
+exports.getChainflipEarlyValidationError = getChainflipEarlyValidationError;
+exports.getEarlyHydradxValidationError = getEarlyHydradxValidationError;
+exports.getSwapAltToken = getSwapAltToken;
+exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
+var _swap = require("@chainflip/sdk/swap");
+var _chainList = require("@subwallet/chain-list");
+var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _swap2 = require("@subwallet/extension-base/types/swap");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
+exports.CHAIN_FLIP_TESTNET_EXPLORER = CHAIN_FLIP_TESTNET_EXPLORER;
+const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
+exports.CHAIN_FLIP_MAINNET_EXPLORER = CHAIN_FLIP_MAINNET_EXPLORER;
+const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
+  [_chainList.COMMON_CHAIN_SLUGS.POLKADOT]: _swap.Chains.Polkadot,
+  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM]: _swap.Chains.Ethereum
+};
+exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = {
+  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]: _swap.Chains.Ethereum,
+  [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT]: _swap.Chains.Polkadot
+};
+exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = {
+  [_chainList.COMMON_ASSETS.DOT]: _swap.Assets.DOT,
+  [_chainList.COMMON_ASSETS.ETH]: _swap.Assets.ETH,
+  [_chainList.COMMON_ASSETS.USDC_ETHEREUM]: _swap.Assets.USDC
+};
+exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
+  [_chainList.COMMON_ASSETS.PDOT]: _swap.Assets.DOT,
+  [_chainList.COMMON_ASSETS.ETH_SEPOLIA]: _swap.Assets.ETH,
+  [_chainList.COMMON_ASSETS.USDC_SEPOLIA]: _swap.Assets.USDC
+};
+exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
+const SWAP_QUOTE_TIMEOUT_MAP = {
+  // in milliseconds
+  default: 30000,
+  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
+  [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+};
+exports.SWAP_QUOTE_TIMEOUT_MAP = SWAP_QUOTE_TIMEOUT_MAP;
+const DEFAULT_SWAP_FIRST_STEP = {
+  id: 0,
+  name: 'Fill information',
+  type: _swap2.SwapStepType.DEFAULT
+};
+exports.DEFAULT_SWAP_FIRST_STEP = DEFAULT_SWAP_FIRST_STEP;
+const MOCK_SWAP_FEE = {
+  feeComponent: [],
+  defaultFeeToken: '',
+  feeOptions: []
+};
+exports.MOCK_SWAP_FEE = MOCK_SWAP_FEE;
+function getSwapAlternativeAsset(swapPair) {
+  var _swapPair$metadata;
+  return swapPair === null || swapPair === void 0 ? void 0 : (_swapPair$metadata = swapPair.metadata) === null || _swapPair$metadata === void 0 ? void 0 : _swapPair$metadata.alternativeAsset;
+}
+function getSwapAltToken(chainAsset) {
+  var _chainAsset$metadata;
+  return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.alternativeSwapAsset;
+}
+function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
+  const bnFromAmount = new _bignumber.default(fromAmount);
+  const bnToAmount = new _bignumber.default(toAmount);
+  const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
+  const bnRate = bnFromAmount.div(bnToAmount);
+  return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+function getChainflipEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case _swap2.SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const parsedMinSwapValue = (0, _utils2.formatNumber)(metadata.minSwap.value, metadata.minSwap.decimals);
+        const message = `Amount too low. Increase your amount above ${parsedMinSwapValue} ${metadata.minSwap.symbol} and try again`;
+        return new _SwapError.SwapError(error, message);
+      }
+    case _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          const parsedMaxSwapValue = (0, _utils2.formatNumber)(metadata.maxSwap.value, metadata.maxSwap.decimals);
+          return new _SwapError.SwapError(error, `Amount too high. Lower your amount below ${parsedMaxSwapValue} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new _SwapError.SwapError(error, 'Amount too high. Lower your amount and try again');
+        }
+      }
+    case _swap2.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap2.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap2.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}
+function getEarlyHydradxValidationError(error, metadata) {
+  switch (error) {
+    case _swap2.SwapErrorType.AMOUNT_CANNOT_BE_ZERO:
+      {
+        return new _SwapError.SwapError(error, 'Amount too low. Increase your amount above 0 and try again');
+      }
+    case _swap2.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap2.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap2.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}

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

@@ -646,6 +646,18 @@ class TransactionService {
           };
           break;
         }
+      case _KoniTypes.ExtrinsicType.SWAP:
+        {
+          const data = (0, _utils3.parseTransactionData)(transaction.data); // TODO: switch by provider
+          const inputAsset = this.state.chainService.getAssetBySlug(data.quote.pair.from);
+          historyItem.amount = {
+            value: data.quote.fromAmount,
+            symbol: (0, _utils._getAssetSymbol)(inputAsset),
+            decimals: (0, _utils._getAssetDecimals)(inputAsset)
+          };
+          historyItem.additionalInfo = data;
+          break;
+        }
       case _KoniTypes.ExtrinsicType.UNKNOWN:
         break;
     }
@@ -742,6 +754,14 @@ class TransactionService {
       }
     } else if ([_KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.STAKING_UNBOND, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE, _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD, _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_POOL_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL].includes(transaction.extrinsicType)) {
       this.state.eventService.emit('transaction.submitStaking', transaction.chain);
+    } else if (transaction.extrinsicType === _KoniTypes.ExtrinsicType.SWAP) {
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
+      const toAssetSlug = inputData.quote.pair.to;
+
+      // todo: consider async
+      this.state.chainService.updateAssetSetting(toAssetSlug, {
+        visible: true
+      }, true).catch(console.error);
     }
   }
   onSuccess(_ref4) {

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

@@ -3,9 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getChainflipExplorerLink = getChainflipExplorerLink;
 exports.getExplorerLink = getExplorerLink;
 exports.parseTransactionData = parseTransactionData;
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -53,4 +55,8 @@ function getExplorerLink(chainInfo, value, type) {
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   return undefined;
+}
+function getChainflipExplorerLink(data, chainInfo) {
+  const chainflipDomain = (0, _utils._isChainTestNet)(chainInfo) ? _utils2.CHAIN_FLIP_TESTNET_EXPLORER : _utils2.CHAIN_FLIP_MAINNET_EXPLORER;
+  return `${chainflipDomain}/channels/${data.depositChannelId}`;
 }

package/cjs/types/balance.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/fee/evm.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/fee/fee.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SWFeeType = exports.SWFee = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let SWFeeType;
+exports.SWFeeType = SWFeeType;
+(function (SWFeeType) {
+  SWFeeType["EIP_1559"] = "EIP_1559";
+  SWFeeType["LEGACY"] = "LEGACY";
+  SWFeeType["SUBSTRATE"] = "SUBSTRATE";
+})(SWFeeType || (exports.SWFeeType = SWFeeType = {}));
+class SWFee {
+  get transactionId() {
+    return this._transactionId;
+  }
+  get selectedFeeOption() {
+    return this._selectedFeeOption;
+  }
+  static build(feeOptions, chain, selectedFeeOption) {
+    // todo: might need to parse metadata depending on the type
+    if (selectedFeeOption) {
+      return new SWFee(feeOptions, chain, selectedFeeOption);
+    } else {
+      const defaultFeeOption = feeOptions.find(option => option.isDefault);
+      return new SWFee(feeOptions, chain, defaultFeeOption);
+    }
+  }
+  static buildSimpleFee(tokenInfo, amount, type) {
+    // used for simple transaction paid in native tokens
+    const defaultOption = {
+      tokenInfo,
+      isDefault: (0, _utils._isNativeToken)(tokenInfo),
+      // if it's the native token of the chain
+      amount,
+      type
+    };
+    return new SWFee([defaultOption], tokenInfo.originChain, defaultOption);
+  }
+  static buildFeeOption(tokenInfo, amount, type) {
+    // todo: calculate totalFeeValue
+    // todo: implement more logic to handle complicated transaction process
+    return {
+      tokenInfo,
+      isDefault: (0, _utils._isNativeToken)(tokenInfo),
+      // if it's the native token of the chain
+      amount,
+      type
+    };
+  }
+  setTransactionId(transactionId) {
+    this._transactionId = transactionId;
+  }
+  setSelectedFeeOption(feeOption) {
+    this._selectedFeeOption = feeOption;
+  }
+  constructor(feeOptions, chain, selectedFeeOption) {
+    this.chain = chain;
+    this.feeOptions = feeOptions;
+    this._selectedFeeOption = selectedFeeOption;
+  }
+  getDefaultFeeOption() {
+    return this.feeOptions.find(option => option.isDefault);
+  }
+}
+exports.SWFee = SWFee;

package/cjs/types/fee/index.js

@@ -1 +1,27 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _evm = require("./evm");
+Object.keys(_evm).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _evm[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _evm[key];
+    }
+  });
+});
+var _fee = require("./fee");
+Object.keys(_fee).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fee[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fee[key];
+    }
+  });
+});

package/cjs/types/service-base.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/swap/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+// core
+let SwapErrorType;
+exports.SwapErrorType = SwapErrorType;
+(function (SwapErrorType) {
+  SwapErrorType["ERROR_FETCHING_QUOTE"] = "ERROR_FETCHING_QUOTE";
+  SwapErrorType["NOT_MEET_MIN_SWAP"] = "NOT_MEET_MIN_SWAP";
+  SwapErrorType["UNKNOWN"] = "UNKNOWN";
+  SwapErrorType["ASSET_NOT_SUPPORTED"] = "ASSET_NOT_SUPPORTED";
+  SwapErrorType["QUOTE_TIMEOUT"] = "QUOTE_TIMEOUT";
+  SwapErrorType["INVALID_RECIPIENT"] = "INVALID_RECIPIENT";
+  SwapErrorType["SWAP_EXCEED_ALLOWANCE"] = "SWAP_EXCEED_ALLOWANCE";
+  SwapErrorType["SWAP_NOT_ENOUGH_BALANCE"] = "SWAP_NOT_ENOUGH_BALANCE";
+  SwapErrorType["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
+  SwapErrorType["AMOUNT_CANNOT_BE_ZERO"] = "AMOUNT_CANNOT_BE_ZERO";
+})(SwapErrorType || (exports.SwapErrorType = SwapErrorType = {}));
+let SwapStepType;
+exports.SwapStepType = SwapStepType;
+(function (SwapStepType) {
+  SwapStepType["DEFAULT"] = "DEFAULT";
+  SwapStepType["TOKEN_APPROVAL"] = "TOKEN_APPROVAL";
+  SwapStepType["SET_FEE_TOKEN"] = "SET_FEE_TOKEN";
+  SwapStepType["SWAP"] = "SWAP";
+  SwapStepType["XCM"] = "XCM";
+})(SwapStepType || (exports.SwapStepType = SwapStepType = {}));
+let SwapProviderId;
+exports.SwapProviderId = SwapProviderId;
+(function (SwapProviderId) {
+  SwapProviderId["CHAIN_FLIP_TESTNET"] = "CHAIN_FLIP_TESTNET";
+  SwapProviderId["CHAIN_FLIP_MAINNET"] = "CHAIN_FLIP_MAINNET";
+  SwapProviderId["HYDRADX_MAINNET"] = "HYDRADX_MAINNET";
+  SwapProviderId["HYDRADX_TESTNET"] = "HYDRADX_TESTNET";
+})(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
+const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET];
+exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
+// process handling
+let SwapFeeType;
+exports.SwapFeeType = SwapFeeType;
+(function (SwapFeeType) {
+  SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
+  SwapFeeType["NETWORK_FEE"] = "NETWORK_FEE";
+  SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
+})(SwapFeeType || (exports.SwapFeeType = SwapFeeType = {}));

package/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/utils/address.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertSubjectInfoToAddresses = void 0;
+exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
+exports.simpleAddress = void 0;
+var _index = require("@subwallet/extension-base/utils/index");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const simpleAddress = address => {
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return address;
+  }
+  return (0, _utilCrypto.encodeAddress)((0, _utilCrypto.decodeAddress)(address));
+};
+exports.simpleAddress = simpleAddress;
+function quickFormatAddressToCompare(address) {
+  if (!(0, _utilCrypto.isAddress)(address)) {
+    return address;
+  }
+  return (0, _index.reformatAddress)(address, 42).toLowerCase();
+}
+const convertSubjectInfoToAddresses = subjectInfo => {
+  return Object.values(subjectInfo).map(info => ({
+    address: info.json.address,
+    type: info.type,
+    ...info.json.meta
+  }));
+};
+exports.convertSubjectInfoToAddresses = convertSubjectInfoToAddresses;

package/cjs/utils/index.js

@@ -236,6 +236,18 @@ Object.keys(_fetchEvmChainInfo).forEach(function (key) {
     }
   });
 });
+var _swap = require("./swap");
+Object.keys(_swap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _swap[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _swap[key];
+    }
+  });
+});
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 

package/cjs/utils/keyring.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPrivateKey = extractPrivateKey;
+exports.unlockAccount = exports.lockAccount = void 0;
+var _uiKeyring = require("@subwallet/ui-keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// import _decode from '@polkadot/keyring/pair/decode';
+
+function extract(address) {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const rs = this.getPair(address);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  console.log(rs.publicKey);
+}
+function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = _uiKeyring.keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+exports.unlockAccount = unlockAccount;
+const lockAccount = address => {
+  try {
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};
+exports.lockAccount = lockAccount;

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/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

@@ -237,5 +237,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>>;
 }