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

package/services/earning-service/handlers/native-staking/relay-chain.js

@@ -3,10 +3,10 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType, ExtrinsicType, StakingTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { calculateAlephZeroValidatorReturn, calculateChainStakedReturnV2, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getAvgValidatorEraReward, getCommission, getMaxValidatorErrorMessage, getMinStakeErrorMessage, getSupportedDaysByHistoryDepth } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { calculateAlephZeroValidatorReturn, calculateChainStakedReturnV2, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getAvgValidatorEraReward, getCommission, getMaxValidatorErrorMessage, getMinStakeErrorMessage, getSupportedDaysByHistoryDepth, getTopValidatorByPoints, getValidatorPointsMap } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
-import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import { _STAKING_CHAIN_GROUP, MaxEraRewardPointsEras } from '@subwallet/extension-base/services/earning-service/constants';
 import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
 import { EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
 import { balanceFormatter, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
@@ -274,11 +274,23 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     if (!poolInfo || !poolInfo.statistic) {
       return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
     }
-    const _era = await chainApi.api.query.staking.currentEra();
+    const [_era, _activeEraInfo] = await Promise.all([chainApi.api.query.staking.currentEra(), chainApi.api.query.staking.activeEra()]);
     const currentEra = _era.toString();
+    const activeEraInfo = _activeEraInfo.toPrimitive();
+    const activeEra = activeEraInfo.index;
     const allValidators = [];
     const validatorInfoList = [];
-    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards, _validators] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data(), chainApi.api.query.staking.validators.entries()]);
+    const maxEraRewardPointsEras = MaxEraRewardPointsEras;
+    const endEraForPoints = parseInt(activeEra) - 1;
+    let startEraForPoints = endEraForPoints - maxEraRewardPointsEras + 1;
+    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards, _validators, ..._eraRewardPoints] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data(), chainApi.api.query.staking.validators.entries(), chainApi.api.query.staking.erasRewardPoints.multi([...Array(maxEraRewardPointsEras).keys()].map(i => i + startEraForPoints))]);
+    const eraRewardMap = {};
+    for (const item of _eraRewardPoints[0]) {
+      eraRewardMap[startEraForPoints] = item.toHuman();
+      startEraForPoints++;
+    }
+    const validatorPointsMap = getValidatorPointsMap(eraRewardMap);
+    const topValidatorList = getTopValidatorByPoints(validatorPointsMap);
 
     // filter blocked validators
     const validators = _validators;
@@ -309,6 +321,11 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
       const rawValidatorStat = item[1].toHuman();
       const validatorAddress = rawValidatorInfo[1];
       if (!blockValidatorList.includes(validatorAddress)) {
+        var _validatorPointsMap$v;
+        let isTopQuartile = false;
+        if (topValidatorList.includes(validatorAddress)) {
+          isTopQuartile = true;
+        }
         const rawTotalStake = rawValidatorStat.total;
         const rawOwnStake = rawValidatorStat.own;
         const bnTotalStake = new BN(rawTotalStake.replaceAll(',', ''));
@@ -333,7 +350,9 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
           blocked: false,
           isVerified: false,
           minBond,
-          isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded)
+          isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded),
+          eraRewardPoint: ((_validatorPointsMap$v = validatorPointsMap[validatorAddress]) !== null && _validatorPointsMap$v !== void 0 ? _validatorPointsMap$v : BN_ZERO).toString(),
+          topQuartile: isTopQuartile
         });
       }
     }

package/services/earning-service/handlers/nomination-pool/index.js

@@ -158,11 +158,25 @@ export default class NominationPoolHandler extends BasePoolHandler {
     if (nominations) {
       const validatorList = nominations.targets;
       await Promise.all(validatorList.map(async validatorAddress => {
-        const _eraStaker = await substrateApi.api.query.staking.erasStakers(currentEra, validatorAddress);
-        const eraStaker = _eraStaker.toPrimitive();
-        const sortedNominators = eraStaker.others.sort((a, b) => {
-          return new BigN(b.value).minus(a.value).toNumber();
-        });
+        let sortedNominators = [];
+        if (['kusama'].includes(this.chain)) {
+          // todo: hot fix for kusama first, we'll review all relaychains later
+          const _eraStaker = await substrateApi.api.query.staking.erasStakersPaged.entries(currentEra, validatorAddress);
+          const eraStakerOtherList = [];
+          _eraStaker.forEach(paged => {
+            const pagedExposure = paged[1].toPrimitive();
+            eraStakerOtherList.push(...pagedExposure.others);
+          });
+          sortedNominators = eraStakerOtherList.sort((a, b) => {
+            return new BigN(b.value).minus(a.value).toNumber();
+          });
+        } else {
+          const _eraStaker = await substrateApi.api.query.staking.erasStakers(currentEra, validatorAddress);
+          const eraStaker = _eraStaker.toPrimitive();
+          sortedNominators = eraStaker.others.sort((a, b) => {
+            return new BigN(b.value).minus(a.value).toNumber();
+          });
+        }
         const topNominators = sortedNominators.map(nominator => {
           return nominator.who;
         }).slice(0, unlimitedNominatorRewarded ? undefined : maxNominatorRewardedPerValidator);

package/services/earning-service/service.js

@@ -396,7 +396,6 @@ export default class EarningService {
   async removeYieldPositions(chains, addresses) {
     const removeKeys = [];
     chains && chains.length > 0 && Object.entries(this.yieldPositionSubject.getValue()).forEach(([key, value]) => {
-      console.log('removeYieldPositions', key, value.chain, chains.indexOf(value.chain) > -1);
       if (chains.indexOf(value.chain) > -1 && !removeKeys.includes(key)) {
         removeKeys.push(key);
       }

package/services/event-service/types.d.ts

@@ -38,6 +38,7 @@ export interface EventRegistry {
     'buy.tokens.ready': [boolean];
     'buy.services.ready': [boolean];
     'earning.ready': [boolean];
+    'swap.ready': [boolean];
 }
 export declare type EventType = keyof EventRegistry;
 export declare const COMMON_RELOAD_EVENTS: EventType[];

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -7,23 +7,10 @@ export default class MigrateTransactionHistoryBySymbol extends BaseMigrationJob
     const state = this.state;
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const allTxs = [];
       await Promise.all(Object.entries(changeSlugsMap).map(async ([oldSlug, newSlug], i) => {

package/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -6,23 +6,10 @@ export default class MigrateAssetSetting extends BaseMigrationJob {
   async run() {
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};

package/services/migration-service/scripts/index.js

@@ -47,9 +47,9 @@ export default {
   '1.1.26-01': MigratePolygonUSDCProvider,
   '1.1.28-01': MigrateEarningVersion,
   '1.1.41-01': DeleteChainStaking,
-  '1.1.44-01': MigrateAssetSetting,
-  '1.1.45-01': MigrateTransactionHistoryBySymbol,
-  '1.1.46-01': AutoEnableSomeTokens
+  '1.1.46-01': AutoEnableSomeTokens,
+  '1.1.53-01': MigrateAssetSetting,
+  '1.1.53-02': MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

package/services/swap-service/handler/base-handler.d.ts

@@ -0,0 +1,38 @@
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { GenSwapStepFunc, OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProvider, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export interface SwapBaseInterface {
+    getSwapQuote: (request: SwapRequest) => Promise<SwapQuote | SwapError>;
+    generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<OptimalSwapPath>;
+    getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    validateSwapRequest: (request: SwapRequest) => Promise<SwapEarlyValidation>;
+    validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
+    handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    isReady?: boolean;
+    init?: () => Promise<void>;
+}
+export interface SwapBaseHandlerInitParams {
+    providerSlug: string;
+    providerName: string;
+    chainService: ChainService;
+    balanceService: BalanceService;
+}
+export declare class SwapBaseHandler {
+    private readonly providerSlug;
+    private readonly providerName;
+    chainService: ChainService;
+    balanceService: BalanceService;
+    constructor({ balanceService, chainService, providerName, providerSlug }: SwapBaseHandlerInitParams);
+    generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<OptimalSwapPath>;
+    validateXcmStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateTokenApproveStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSetFeeTokenStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
+    get name(): string;
+    get slug(): string;
+    get providerInfo(): SwapProvider;
+}

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

@@ -0,0 +1,180 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DEFAULT_SWAP_FIRST_STEP, getSwapAlternativeAsset, MOCK_SWAP_FEE } from '@subwallet/extension-base/services/swap-service/utils';
+import { SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
+import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export class SwapBaseHandler {
+  constructor({
+    balanceService,
+    chainService,
+    providerName,
+    providerSlug
+  }) {
+    this.providerName = providerName;
+    this.providerSlug = providerSlug;
+    this.chainService = chainService;
+    this.balanceService = balanceService;
+  }
+
+  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+  async generateOptimalProcess(params, genStepFuncList) {
+    const result = {
+      totalFee: [MOCK_SWAP_FEE],
+      steps: [DEFAULT_SWAP_FIRST_STEP]
+    };
+    try {
+      for (const genStepFunc of genStepFuncList) {
+        const step = await genStepFunc.bind(this, params)();
+        if (step) {
+          result.steps.push({
+            id: result.steps.length,
+            ...step[0]
+          });
+          result.totalFee.push(step[1]);
+        }
+      }
+      return result;
+    } catch (e) {
+      return result;
+    }
+  }
+  async validateXcmStep(params, stepIndex) {
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const swapPair = params.selectedQuote.pair;
+    const alternativeAssetSlug = getSwapAlternativeAsset(swapPair);
+    if (!alternativeAssetSlug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
+    const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
+    const xcmFee = new BigNumber(xcmFeeComponent.amount || '0');
+    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    if (_isNativeToken(alternativeAsset)) {
+      xcmAmount = xcmAmount.plus(xcmFee);
+    }
+    const alternativeTokenMinAmount = new BigNumber(alternativeAsset.minAmount || '0');
+    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
+      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
+      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
+      const symbol = altInputTokenInfo.symbol;
+      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
+      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      const inputNetworkName = chain.name;
+      const altNetworkName = alternativeChain.name;
+      const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
+      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxXCMValue = formatNumber(bnMaxXCM.toString(), fromAsset.decimals || 0);
+      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
+        return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
+      }
+      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
+        replace: {
+          symbol,
+          maxValue,
+          inputNetworkName,
+          altNetworkName,
+          currentValue,
+          maxXCMValue
+        }
+      }))];
+    }
+    return [];
+  }
+  async validateTokenApproveStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSetFeeTokenStep(params, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeInfo = params.process.totalFee[stepIndex];
+    const feeAmount = feeInfo.feeComponent[0];
+    const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
+    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
+    const bnFeeAmount = new BigNumber(feeAmount.amount);
+    if (bnFeeAmount.gte(bnFeeTokenBalance)) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)]);
+    }
+    return [];
+  }
+  async validateSwapStep(params, isXcmOk, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const selectedQuote = params.selectedQuote;
+    const currentTimestamp = +Date.now();
+    if (selectedQuote.aliveUntil <= currentTimestamp) {
+      return Promise.resolve([new TransactionError(SwapErrorType.QUOTE_TIMEOUT)]);
+    }
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const stepFee = params.process.totalFee[stepIndex].feeComponent;
+    const networkFee = stepFee.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
+    if (!networkFee) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
+    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    const bnFeeAmount = new BigNumber(networkFee.amount);
+    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    }
+    if (fromAsset.slug === feeTokenInfo.slug) {
+      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
+        return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
+      }
+    }
+    if (params.selectedQuote.minSwap) {
+      const minProtocolSwap = new BigNumber(params.selectedQuote.minSwap);
+      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
+        const parsedMinSwapValue = formatNumber(minProtocolSwap, _getAssetDecimals(fromAsset));
+        return Promise.resolve([new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
+      }
+    }
+
+    const bnSrcAssetMinAmount = new BigNumber(_getTokenMinAmount(fromAsset));
+    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
+    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
+      const parsedMaxBalanceSwap = formatNumber(bnMaxBalanceSwap, _getAssetDecimals(fromAsset));
+      return Promise.resolve([new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
+    }
+    if (params.recipient) {
+      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+      const isEvmAddress = isEthereumAddress(params.recipient);
+      const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
+      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+        return Promise.resolve([new TransactionError(SwapErrorType.INVALID_RECIPIENT)]);
+      }
+    }
+    return Promise.resolve([]);
+  }
+  get name() {
+    return this.providerName;
+  }
+  get slug() {
+    return this.providerSlug;
+  }
+  get providerInfo() {
+    return {
+      id: this.providerSlug,
+      name: this.providerName
+    };
+  }
+}

package/services/swap-service/handler/chainflip-handler.d.ts

@@ -0,0 +1,30 @@
+import { COMMON_ASSETS } from '@subwallet/chain-list';
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export declare class ChainflipSwapHandler implements SwapBaseInterface {
+    private swapSdk;
+    private readonly isTestnet;
+    private swapBaseHandler;
+    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    get assetMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").A>;
+    get chainMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").C>;
+    get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
+    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
+    private parseSwapPath;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
+}