@subwallet/extension-base 1.2.13-0 → 1.2.15-0

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

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReserveForPool = exports.getReserveForPath = exports.estimateTokensForPool = exports.estimateTokensForPath = exports.estimateRateForPath = exports.estimateRateAfter = exports.estimatePriceImpactPct = exports.estimateActualRate = exports.checkMinAmountForPool = exports.checkMinAmountForPath = exports.checkLiquidityForPool = exports.checkLiquidityForPath = exports.buildSwapExtrinsic = exports._getPoolInfo = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const _getPoolInfo = async (api, asset1, asset2) => {
+  const assetLocation1 = (0, _utils._getXcmAssetMultilocation)(asset1);
+  const assetLocation2 = (0, _utils._getXcmAssetMultilocation)(asset2);
+  const rs = await api.call.assetConversionApi.getReserves(assetLocation1, assetLocation2);
+  if (!rs) {
+    return ['0', '0'];
+  }
+  const [balanceAsset1, balanceAsset2] = rs.unwrapOrDefault();
+  return [balanceAsset1.toString(), balanceAsset2.toString()];
+};
+exports._getPoolInfo = _getPoolInfo;
+const getReserveForPool = async (api, asset1, asset2) => {
+  let [balanceAsset1, balanceAsset2] = await _getPoolInfo(api, asset1, asset2);
+  if (balanceAsset1 !== '0' && balanceAsset2 !== '0') {
+    return [balanceAsset1, balanceAsset2];
+  } else {
+    [balanceAsset2, balanceAsset1] = await _getPoolInfo(api, asset2, asset1);
+    return [balanceAsset1, balanceAsset2];
+  }
+};
+exports.getReserveForPool = getReserveForPool;
+const getReserveForPath = async (api, paths) => {
+  const pairs = [];
+  for (let i = 0; i < paths.length - 1; i++) {
+    const asset1 = paths[i];
+    const asset2 = paths[i + 1];
+    pairs.push([asset1, asset2]);
+  }
+  return await Promise.all(pairs.map(async _ref => {
+    let [asset1, asset2] = _ref;
+    return getReserveForPool(api, asset1, asset2);
+  }));
+};
+exports.getReserveForPath = getReserveForPath;
+const estimateTokensForPool = (amount, reserves) => {
+  if (amount === '0') {
+    return '0';
+  }
+  return new _bignumber.default(amount).times(reserves[1]).div(reserves[0]).integerValue(_bignumber.default.ROUND_DOWN).toString();
+};
+exports.estimateTokensForPool = estimateTokensForPool;
+const estimateTokensForPath = (amount, reserves) => {
+  const result = [amount];
+  for (let i = 0; i < reserves.length; i++) {
+    const reserve = reserves[i];
+    const currentAmount = result[i];
+    const nextAmount = estimateTokensForPool(currentAmount, reserve);
+    result.push(nextAmount);
+  }
+  return result;
+};
+exports.estimateTokensForPath = estimateTokensForPath;
+const estimateRateForPath = reserves => {
+  let result = new _bignumber.default(1);
+  for (const reserve of reserves) {
+    result = result.times(reserve[0]).div(reserve[1]);
+  }
+  return result.toString();
+};
+exports.estimateRateForPath = estimateRateForPath;
+const estimateActualRate = (amount, reserves) => {
+  let result = new _bignumber.default(1);
+  const m = new _bignumber.default(amount);
+
+  // Currently support for direct path swap only
+  for (const reserve of reserves) {
+    const x = new _bignumber.default(reserve[0]);
+    const y = new _bignumber.default(reserve[1]);
+    result = result.times(x.plus(m)).div(y);
+  }
+  return result.toString();
+};
+exports.estimateActualRate = estimateActualRate;
+const estimateRateAfter = (amount, reserves) => {
+  const m = new _bignumber.default(amount);
+  const reserve = reserves[0];
+  const x = new _bignumber.default(reserve[0]);
+  const y = new _bignumber.default(reserve[1]);
+  const n = y.multipliedBy(m).div(x.plus(m));
+  const result = x.plus(m).div(y.minus(n));
+  return result.toString();
+};
+exports.estimateRateAfter = estimateRateAfter;
+const estimatePriceImpactPct = (marketRate, marketRateAfter) => {
+  const bnMarketRate = new _bignumber.default(marketRate);
+  const bnActualRate = new _bignumber.default(marketRateAfter);
+  return new _bignumber.default(1).minus(bnMarketRate.div(bnActualRate)).multipliedBy(100).toString();
+};
+exports.estimatePriceImpactPct = estimatePriceImpactPct;
+const checkLiquidityForPool = (amount, reserve1, reserve2) => {
+  if (new _bignumber.default(reserve1).eq('0') || new _bignumber.default(reserve2).eq('0')) {
+    return _swap.SwapErrorType.ASSET_NOT_SUPPORTED;
+  } else if (new _bignumber.default(reserve1).lt(amount)) {
+    return _swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY;
+  }
+  return undefined;
+};
+exports.checkLiquidityForPool = checkLiquidityForPool;
+const checkLiquidityForPath = (amounts, reserves) => {
+  for (let i = 0; i < reserves.length; i++) {
+    const amount = amounts[i];
+    const [reserve1, reserve2] = reserves[i];
+    const error = checkLiquidityForPool(amount, reserve1, reserve2);
+    if (error) {
+      return error;
+    }
+  }
+  return undefined;
+};
+
+// Swap from asset1 to asset2
+exports.checkLiquidityForPath = checkLiquidityForPath;
+const checkMinAmountForPool = (reserve1, reserve2, amount1, amount2, minAmount1, minAmount2) => {
+  const newReserve1 = new _bignumber.default(reserve1).plus(amount1);
+  const newReserve2 = new _bignumber.default(reserve2).minus(amount2);
+  if (newReserve1.lt(minAmount1) || newReserve2.lt(minAmount2)) {
+    return _swap.SwapErrorType.MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT;
+  }
+  return undefined;
+};
+exports.checkMinAmountForPool = checkMinAmountForPool;
+const checkMinAmountForPath = (reserves, amounts, minAmounts) => {
+  for (let i = 0; i < reserves.length; i++) {
+    const [amount1, amount2] = amounts.slice(i, 2);
+    const [minAmount1, minAmount2] = minAmounts.slice(i, 2);
+    const [reserve1, reserve2] = reserves[i];
+    const error = checkMinAmountForPool(reserve1, reserve2, amount1, amount2, minAmount1, minAmount2);
+    if (error) {
+      return error;
+    }
+  }
+  return undefined;
+};
+
+// Build extrinsic for swap
+exports.checkMinAmountForPath = checkMinAmountForPath;
+const buildSwapExtrinsic = function (api, paths, recipient, amountIn, amountOutMin) {
+  let keepAlive = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+  const pathsInfo = paths.map(asset => {
+    const multilocation = (0, _utils._getXcmAssetMultilocation)(asset);
+    return api.createType('MultiLocation', multilocation).toU8a();
+  });
+  return api.tx.assetConversion.swapExactTokensForTokens(pathsInfo, amountIn, amountOutMin, recipient, keepAlive);
+};
+exports.buildSwapExtrinsic = buildSwapExtrinsic;

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

@@ -8,6 +8,7 @@ var _SwapError = require("@subwallet/extension-base/background/errors/SwapError"
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _types = require("@subwallet/extension-base/services/base/types");
+var _assetHub = require("@subwallet/extension-base/services/swap-service/handler/asset-hub");
 var _chainflipHandler = require("@subwallet/extension-base/services/swap-service/handler/chainflip-handler");
 var _hydradxHandler = require("@subwallet/extension-base/services/swap-service/handler/hydradx-handler");
 var _utils = require("@subwallet/extension-base/services/swap-service/utils");
@@ -97,7 +98,6 @@ class SwapService {
       request,
       selectedQuote: swapQuoteResponse.optimalQuote
     });
-    console.log('optimalProcess', optimalProcess);
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
@@ -147,6 +147,15 @@ class SwapService {
         case _swap.SwapProviderId.HYDRADX_MAINNET:
           this.handlers[providerId] = new _hydradxHandler.HydradxHandler(this.chainService, this.state.balanceService, false);
           break;
+        case _swap.SwapProviderId.POLKADOT_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemint');
+          break;
+        case _swap.SwapProviderId.KUSAMA_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemine');
+          break;
+        case _swap.SwapProviderId.ROCOCO_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
+          break;
         default:
           throw new Error('Unsupported provider');
       }

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = 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.convertSwapRate = convertSwapRate;
 exports.getSwapAltToken = getSwapAltToken;
 exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
 var _swap = require("@chainflip/sdk/swap");
@@ -53,7 +54,10 @@ const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [_swap2.SwapProviderId.HYDRADX_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX],
   [_swap2.SwapProviderId.HYDRADX_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
   [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM],
-  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]
+  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
+  [_swap2.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
+  [_swap2.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
+  [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB]
 };
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = _PROVIDER_TO_SUPPORTED_PAIR_MAP;
 function getSwapAlternativeAsset(swapPair) {
@@ -70,4 +74,9 @@ function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
   const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
   const bnRate = bnFromAmount.div(bnToAmount);
   return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+function convertSwapRate(rate, fromAsset, toAsset) {
+  const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
+  const bnRate = new _bignumber.default(rate);
+  return bnRate.times(10 ** decimalDiff).pow(-1).toNumber();
 }

package/cjs/types/swap/index.js

@@ -19,6 +19,7 @@ exports.SwapErrorType = SwapErrorType;
   SwapErrorType["SWAP_EXCEED_ALLOWANCE"] = "SWAP_EXCEED_ALLOWANCE";
   SwapErrorType["SWAP_NOT_ENOUGH_BALANCE"] = "SWAP_NOT_ENOUGH_BALANCE";
   SwapErrorType["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
+  SwapErrorType["MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
   SwapErrorType["AMOUNT_CANNOT_BE_ZERO"] = "AMOUNT_CANNOT_BE_ZERO";
 })(SwapErrorType || (exports.SwapErrorType = SwapErrorType = {}));
 let SwapStepType;
@@ -33,8 +34,11 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["CHAIN_FLIP_MAINNET"] = "CHAIN_FLIP_MAINNET";
   SwapProviderId["HYDRADX_MAINNET"] = "HYDRADX_MAINNET";
   SwapProviderId["HYDRADX_TESTNET"] = "HYDRADX_TESTNET";
+  SwapProviderId["POLKADOT_ASSET_HUB"] = "POLKADOT_ASSET_HUB";
+  SwapProviderId["KUSAMA_ASSET_HUB"] = "KUSAMA_ASSET_HUB";
+  SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
 })(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
-const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET];
+const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;

package/core/logic-validation/swap.d.ts

@@ -1,8 +1,10 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SwapErrorType } from '@subwallet/extension-base/types/swap';
+import { AssetHubPreValidationMetadata, ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SwapErrorType } from '@subwallet/extension-base/types/swap';
+export declare function _validateBalanceToSwapOnAssetHub(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateBalanceToSwap(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateSwapRecipient(destChainInfo: _ChainInfo, recipient: string): TransactionError | undefined;
 export declare function _getChainflipEarlyValidationError(error: SwapErrorType, metadata: ChainflipPreValidationMetadata): SwapError;
 export declare function _getEarlyHydradxValidationError(error: SwapErrorType, metadata: HydradxPreValidationMetadata): SwapError;
+export declare function _getEarlyAssetHubValidationError(error: SwapErrorType, metadata: AssetHubPreValidationMetadata): SwapError;

package/core/logic-validation/swap.js

@@ -4,17 +4,51 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { _getAssetDecimals, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapErrorType } from '@subwallet/extension-base/types/swap';
 import { formatNumber } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { isEthereumAddress } from '@polkadot/util-crypto';
+export function _validateBalanceToSwapOnAssetHub(fromToken, feeToken, feeTokenChainInfo, feeAmount, fromTokenBalance, feeTokenBalance, swapAmount, isXcmOk, minSwap) {
+  const bnFromTokenBalance = new BigN(fromTokenBalance);
+  if (!_isNativeToken(fromToken) && bnFromTokenBalance.minus(swapAmount).lt(_getTokenMinAmount(fromToken))) {
+    const parsedMaxBalanceSwap = formatNumber(bnFromTokenBalance.minus(_getTokenMinAmount(fromToken)), _getAssetDecimals(fromToken));
+    return new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnFromTokenBalance.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
+  }
+  if (new BigN(feeTokenBalance).lte(feeAmount)) {
+    return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
+  }
+  if (!_isNativeToken(fromToken) && fromToken.slug === feeToken.slug) {
+    // todo: need review and refactor
+    if (bnFromTokenBalance.lte(new BigN(feeAmount).plus(swapAmount))) {
+      return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+    }
+  }
+  if (isXcmOk) {
+    // assume that the swap is valid if XCM is in the process and it was successful
+    return undefined;
+  }
+  if (minSwap) {
+    if (bnFromTokenBalance.lte(minSwap)) {
+      const parsedMinSwapValue = formatNumber(minSwap, _getAssetDecimals(fromToken));
+      return new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromToken.symbol} to start swapping. Deposit ${fromToken.symbol} and try again.`); // todo: min swap or amount?
+    }
+  }
+
+  if (new BigN(swapAmount).gte(fromTokenBalance)) {
+    const parsedMaxBalanceSwap = formatNumber(fromTokenBalance, _getAssetDecimals(fromToken));
+    return new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnFromTokenBalance.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
+  }
+  return undefined;
+}
 export function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, feeAmount, fromTokenBalance, feeTokenBalance, swapAmount, isXcmOk, minSwap) {
+  const bnFromTokenBalance = new BigN(fromTokenBalance);
   if (new BigN(feeTokenBalance).lte(feeAmount)) {
     return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${feeTokenChainInfo.name}) to pay transaction fee`);
   }
   if (fromToken.slug === feeToken.slug) {
-    if (new BigN(fromTokenBalance).lte(new BigN(feeAmount).plus(swapAmount))) {
+    // todo: need review and refactor
+    if (bnFromTokenBalance.lte(new BigN(feeAmount).plus(swapAmount))) {
       return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
     }
   }
@@ -23,7 +57,7 @@ export function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, f
     return undefined;
   }
   if (minSwap) {
-    if (new BigN(fromTokenBalance).lte(minSwap)) {
+    if (bnFromTokenBalance.lte(minSwap)) {
       const parsedMinSwapValue = formatNumber(minSwap, _getAssetDecimals(fromToken));
       return new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromToken.symbol} to start swapping. Deposit ${fromToken.symbol} and try again.`); // todo: min swap or amount?
     }
@@ -31,7 +65,7 @@ export function _validateBalanceToSwap(fromToken, feeToken, feeTokenChainInfo, f
 
   if (new BigN(swapAmount).gte(fromTokenBalance)) {
     const parsedMaxBalanceSwap = formatNumber(fromTokenBalance, _getAssetDecimals(fromToken));
-    return new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${new BigN(fromTokenBalance).gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
+    return new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnFromTokenBalance.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromToken.symbol}` : ''} and try again`);
   }
   return undefined;
 }
@@ -86,4 +120,21 @@ export function _getEarlyHydradxValidationError(error, metadata) {
     default:
       return new SwapError(error);
   }
+}
+export function _getEarlyAssetHubValidationError(error, metadata) {
+  switch (error) {
+    case SwapErrorType.AMOUNT_CANNOT_BE_ZERO:
+      return new SwapError(error, 'Amount too low. Increase your amount above 0 and try again');
+    case SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new SwapError(error, 'This swap pair is not supported');
+    case SwapErrorType.UNKNOWN:
+      return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    case SwapErrorType.MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT:
+      return new SwapError(error, 'You swap too much. It make pool not enough existential deposit');
+    // TODO: i18n this
+    default:
+      return new SwapError(error);
+  }
 }

package/core/substrate/nominationpools-pallet.js

@@ -6,7 +6,8 @@ export function _getActiveStakeInNominationPool(memberInfo) {
   return new BigN(memberInfo.points.toString());
 }
 export function _getUnbondingStakeInNominationPool(memberInfo) {
-  return new BigN(Object.values(memberInfo.unbondingEras).reduce((a, b) => a + b, 0));
+  const unbondingValues = Object.values(memberInfo.unbondingEras).map(unbonding => new BigN(unbonding));
+  return new BigN(Object.values(unbondingValues).reduce((a, b) => a.plus(b), new BigN(0)));
 }
 export function _getTotalStakeInNominationPool(memberInfo) {
   return _getActiveStakeInNominationPool(memberInfo).plus(_getUnbondingStakeInNominationPool(memberInfo));

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

@@ -47,6 +47,7 @@ export declare enum SUPPORTED_TRANSFER_EVM_CHAIN_NAME {
     shibuya = "shibuya"
 }
 export declare const SUPPORTED_TRANSFER_EVM_CHAIN: string[];
+export declare const UNSUPPORTED_TRANSFER_EVM_CHAIN_NAME: string[];
 export declare const TRANSFER_CHAIN_ID: {
     [x: string]: number;
 };

package/koni/api/nft/config.js

@@ -1,7 +1,8 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { isFirefox, RuntimeInfo } from '@subwallet/extension-base/utils';
+import { isFirefox, RuntimeInfo } from '@subwallet/extension-base/utils/environment'; // do not change to shorten path, avoid circle import
+
 export const SINGULAR_V1_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account-rmrk1/';
 export const SINGULAR_V2_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account/';
 export const KANARIA_ENDPOINT = 'https://kanaria.rmrk.app/api/rmrk2/';
@@ -73,6 +74,7 @@ export let SUPPORTED_TRANSFER_EVM_CHAIN_NAME;
   SUPPORTED_TRANSFER_EVM_CHAIN_NAME["shibuya"] = "shibuya";
 })(SUPPORTED_TRANSFER_EVM_CHAIN_NAME || (SUPPORTED_TRANSFER_EVM_CHAIN_NAME = {}));
 export const SUPPORTED_TRANSFER_EVM_CHAIN = [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbase, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbeam, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonriver, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.astarEvm, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shiden, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shibuya];
+export const UNSUPPORTED_TRANSFER_EVM_CHAIN_NAME = ['unique_evm'];
 export const TRANSFER_CHAIN_ID = {
   [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbase]: 1287,
   [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbeam]: 1284,
@@ -106,24 +108,34 @@ if (isFirefox) {
 if (RuntimeInfo.protocol && RuntimeInfo.protocol.startsWith('http')) {
   // This is for https
   if (RuntimeInfo.protocol.startsWith('https')) {
-    RANDOM_IPFS_GATEWAY_SETTING.push({
-      provider: IPFS_FLEEK,
-      weight: 4
-    }, {
-      provider: IPFS_GATEWAY_4EVERLAND,
-      weight: 2
-    }, {
-      provider: IPFS_W3S_LINK,
-      weight: 1
-    }, {
-      provider: CF_IPFS_GATEWAY,
-      weight: 4
-    }, {
-      provider: PINATA_IPFS_GATEWAY,
-      weight: 1 // Rate limit too low
-    }, {
-      provider: IPFS_IO,
-      weight: 5
+    RANDOM_IPFS_GATEWAY_SETTING.push(
+    // {
+    //   provider: IPFS_FLEEK,
+    //   weight: 4
+    // },
+    // {
+    //   provider: IPFS_GATEWAY_4EVERLAND,
+    //   weight: 2
+    // },
+    // {
+    //   provider: IPFS_W3S_LINK,
+    //   weight: 1
+    // },
+    // {
+    //   provider: CF_IPFS_GATEWAY,
+    //   weight: 4
+    // },
+    // {
+    //   provider: PINATA_IPFS_GATEWAY,
+    //   weight: 1 // Rate limit too low
+    // },
+    // {
+    //   provider: IPFS_IO,
+    //   weight: 5
+    // },
+    {
+      provider: SUBWALLET_IPFS,
+      weight: 10
     });
   }
 } else {

package/koni/api/nft/index.js

@@ -17,7 +17,7 @@ import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft
 import { categoryAddresses, targetIsWeb } from '@subwallet/extension-base/utils';
 import AssetHubNftsPalletApi from "./assethub_nft/index.js";
 function createSubstrateNftApi(chain, substrateApi, addresses) {
-  const [substrateAddresses] = categoryAddresses(addresses);
+  const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
   if (_NFT_CHAIN_GROUP.acala.includes(chain)) {
     return [new AcalaNftApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.karura.includes(chain)) {
@@ -30,6 +30,8 @@ function createSubstrateNftApi(chain, substrateApi, addresses) {
     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)];
+  } else if (_NFT_CHAIN_GROUP.unique_evm.includes(chain)) {
+    return [new UniqueNftApi(chain, evmAddresses)];
   } else if (_NFT_CHAIN_GROUP.bitcountry.includes(chain)) {
     return [new BitCountryNftApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.vara.includes(chain)) {
@@ -119,6 +121,12 @@ export class NftHandler {
               }
             }
           }
+          if (chain === 'unique_evm') {
+            const handlers = createSubstrateNftApi(chain, null, evmAddresses);
+            if (handlers && !!handlers.length) {
+              this.handlers.push(...handlers);
+            }
+          }
           if (_isChainSupportWasmNft(chainInfo)) {
             if (this.substrateApiMap[chain]) {
               const handler = createWasmNftApi(chain, this.substrateApiMap[chain], substrateAddresses);

package/koni/api/nft/unique_network_nft/index.js

@@ -3,6 +3,7 @@
 
 import { OPAL_SCAN_ENDPOINT, QUARTZ_SCAN_ENDPOINT, UNIQUE_IPFS_GATEWAY, UNIQUE_SCAN_ENDPOINT } from '@subwallet/extension-base/koni/api/nft/config';
 import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _NFT_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { baseParseIPFSUrl } from '@subwallet/extension-base/utils';
 import { decodeAddress, encodeAddress } from '@polkadot/util-crypto';
 export class UniqueNftApi extends BaseNftApi {
@@ -15,23 +16,13 @@ export class UniqueNftApi extends BaseNftApi {
   handleProperties(nft) {
     const propertiesMap = {};
     const attRecord = nft.attributes;
-    if (attRecord) {
-      for (const item in attRecord) {
-        const attName = attRecord[item].name._;
-        const attInfo = attRecord[item].value;
-        if (Array.isArray(attInfo)) {
-          const attList = [];
-          for (const trait of attInfo) {
-            attList.push(trait._);
-          }
-          propertiesMap[attName] = {
-            value: attList
-          };
-        } else {
-          propertiesMap[attName] = {
-            value: attInfo._
-          };
-        }
+    if (attRecord.length) {
+      for (const item of attRecord) {
+        const attName = item.trait_type;
+        const attInfo = item.value;
+        propertiesMap[attName] = {
+          value: attInfo
+        };
       }
     }
     return propertiesMap;
@@ -78,8 +69,10 @@ export class UniqueNftApi extends BaseNftApi {
       endpoint = OPAL_SCAN_ENDPOINT;
       uniqueAddress = address;
       // Opal address: Normal address
+    } else if (_NFT_CHAIN_GROUP.unique_evm.includes(this.chain)) {
+      endpoint = UNIQUE_SCAN_ENDPOINT;
+      uniqueAddress = address.toLowerCase();
     }
-
     const resp = await fetch(endpoint, {
       method: 'post',
       headers: {
@@ -99,7 +92,6 @@ export class UniqueNftApi extends BaseNftApi {
         if (nfts) {
           const collectionMap = {};
           for (const nft of nfts) {
-            var _nft$image;
             // Handle case rendering image on Quartz Network (Temporary solution)
             if (this.chain === 'quartz' && nft.collection_id.toString() === '141') {
               continue;
@@ -114,7 +106,7 @@ export class UniqueNftApi extends BaseNftApi {
               chain: this.chain,
               owner: address,
               name: nft.token_name,
-              image: this.parseUrl((_nft$image = nft.image) === null || _nft$image === void 0 ? void 0 : _nft$image.fullUrl),
+              image: this.parseUrl(nft.image),
               description: nft.collection_description,
               collectionId: nft.collection_id.toString(),
               properties: propertiesMap

package/koni/background/handlers/Extension.js

@@ -15,6 +15,7 @@ import { getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/c
 import { isSnowBridgeGatewayContract } from '@subwallet/extension-base/koni/api/contract-handler/utils';
 import { resolveAzeroAddressToDomain, resolveAzeroDomainToAddress } from '@subwallet/extension-base/koni/api/dotsama/domain';
 import { parseSubstrateTransaction } from '@subwallet/extension-base/koni/api/dotsama/parseTransaction';
+import { UNSUPPORTED_TRANSFER_EVM_CHAIN_NAME } from '@subwallet/extension-base/koni/api/nft/config';
 import { getNftTransferExtrinsic, isRecipientSelf } from '@subwallet/extension-base/koni/api/nft/transfer';
 import { getBondingExtrinsic, getCancelWithdrawalExtrinsic, getClaimRewardExtrinsic, getNominationPoolsInfo, getUnbondingExtrinsic, getValidatorsInfo, validateBondingCondition, validateUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding';
 import { getTuringCancelCompoundingExtrinsic, getTuringCompoundExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
@@ -1797,6 +1798,17 @@ export default class KoniExtension {
     } = inputData;
     const contractAddress = params.contractAddress;
     const tokenId = params.tokenId;
+    if (UNSUPPORTED_TRANSFER_EVM_CHAIN_NAME.includes(networkKey)) {
+      return await this.#koniState.transactionService.handleTransaction({
+        address: senderAddress,
+        chain: networkKey,
+        chainType: ChainType.EVM,
+        data: inputData,
+        extrinsicType: ExtrinsicType.SEND_NFT,
+        transaction: null,
+        url: EXTENSION_REQUEST_URL
+      });
+    }
     const transaction = await getERC721Transaction(this.#koniState.getEvmApi(networkKey), networkKey, contractAddress, senderAddress, recipientAddress, tokenId);
 
     // this.addContact(recipientAddress);