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

package/services/chain-service/utils/index.d.ts

@@ -51,14 +51,15 @@ export declare function _isSubstrateRelayChain(chainInfo: _ChainInfo): boolean;
 export declare function _isSubstrateParaChain(chainInfo: _ChainInfo): boolean;
 export declare function _getEvmAbiExplorer(chainInfo: _ChainInfo): string;
 export declare function _isAssetValuable(assetInfo: _ChainAsset): boolean;
-export declare function _getMultiChainAsset(assetInfo: _ChainAsset): string;
-export declare function _getAssetPriceId(assetInfo: _ChainAsset): string;
+export declare function _getMultiChainAsset(assetInfo?: _ChainAsset): string;
+export declare function _getAssetPriceId(assetInfo?: _ChainAsset): string;
+export declare function _getAssetName(assetInfo?: _ChainAsset): string;
 export declare function _getMultiChainAssetPriceId(multiChainAsset: _MultiChainAsset): string;
-export declare function _getAssetSymbol(assetInfo: _ChainAsset): string;
+export declare function _getAssetSymbol(assetInfo?: _ChainAsset): string;
 export declare function _getMultiChainAssetSymbol(multiChainAsset: _MultiChainAsset): string;
-export declare function _getAssetOriginChain(assetInfo: _ChainAsset): string;
+export declare function _getAssetOriginChain(assetInfo?: _ChainAsset): string;
 export declare function _getChainName(chainInfo: _ChainInfo): string;
-export declare function _getAssetDecimals(assetInfo: _ChainAsset): number;
+export declare function _getAssetDecimals(assetInfo?: _ChainAsset): number;
 export declare function _getBlockExplorerFromChain(chainInfo: _ChainInfo): string | undefined;
 export declare function _parseMetadataForSmartContractAsset(contractAddress: string): Record<string, string>;
 export declare function _isChainTestNet(chainInfo: _ChainInfo): boolean;
@@ -74,6 +75,7 @@ export declare function randomizeProvider(providers: Record<string, string>, exc
     providerKey: string;
     providerValue: string;
 };
+export declare function _isAssetCanPayTxFee(chainAsset: _ChainAsset): boolean;
 export declare function updateLatestChainInfo(currentDataMap: _DataMap, latestChainInfoList: _ChainInfo[]): {
     storedChainInfoList: IChain[];
     needUpdateChainApiList: _ChainInfo[];

package/services/chain-service/utils/index.js

@@ -280,6 +280,9 @@ export function _getMultiChainAsset(assetInfo) {
 export function _getAssetPriceId(assetInfo) {
   return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.priceId) || '';
 }
+export function _getAssetName(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.name) || '';
+}
 export function _getMultiChainAssetPriceId(multiChainAsset) {
   return (multiChainAsset === null || multiChainAsset === void 0 ? void 0 : multiChainAsset.priceId) || '';
 }
@@ -290,13 +293,13 @@ export function _getMultiChainAssetSymbol(multiChainAsset) {
   return multiChainAsset.symbol;
 }
 export function _getAssetOriginChain(assetInfo) {
-  return assetInfo.originChain;
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.originChain) || '';
 }
 export function _getChainName(chainInfo) {
   return chainInfo.name;
 }
 export function _getAssetDecimals(assetInfo) {
-  return assetInfo.decimals || 0;
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.decimals) || 0;
 }
 export function _getBlockExplorerFromChain(chainInfo) {
   let blockExplorer;
@@ -395,6 +398,10 @@ export function randomizeProvider(providers, excludedKeys) {
     providerValue: selectedProviderValue
   };
 }
+export function _isAssetCanPayTxFee(chainAsset) {
+  var _ref, _chainAsset$metadata;
+  return (_ref = (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.canPayTxFee) !== null && _ref !== void 0 ? _ref : false;
+}
 export function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
   const currentChainInfoMap = currentDataMap.chainInfoMap;
   const currentChainStateMap = currentDataMap.chainStateMap;

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ import fetch from 'cross-fetch';
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
-const ChainListVersion = '0.2.54';
+const ChainListVersion = '0.2.55';
 export async function fetchPatchData(slug) {
   try {
     const fetchPromise = fetch(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);

package/services/earning-service/constants/chains.d.ts

@@ -13,6 +13,7 @@ export declare const _STAKING_CHAIN_GROUP: {
     krest_network: string[];
     manta: string[];
 };
+export declare const MaxEraRewardPointsEras = 14;
 export declare const ST_LIQUID_TOKEN_ABI: Record<string, any>;
 export declare const MANTA_VALIDATOR_POINTS_PER_BLOCK = 20;
 export declare const MANTA_MIN_DELEGATION = 500;

package/services/earning-service/constants/chains.js

@@ -18,6 +18,7 @@ export const _STAKING_CHAIN_GROUP = {
   krest_network: ['krest_network'],
   manta: ['manta_network']
 };
+export const MaxEraRewardPointsEras = 14;
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
 export const ST_LIQUID_TOKEN_ABI = require("./abis/st_liquid_token_abi.json");

package/services/earning-service/handlers/native-staking/astar.js

@@ -242,11 +242,12 @@ export default class AstarNativeStakingPoolHandler extends BaseParaNativeStaking
     };
   }
   async subscribePoolPosition(useAddresses, resultCallback) {
+    var _substrateApi$api$que;
     let cancel = false;
     const substrateApi = await this.substrateApi.isReady;
     const defaultInfo = this.baseInfo;
     const chainInfo = this.chainInfo;
-    const unsub = await substrateApi.api.query.dappsStaking.ledger.multi(useAddresses, async ledgers => {
+    const unsub = await ((_substrateApi$api$que = substrateApi.api.query.dappsStaking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, async ledgers => {
       if (cancel) {
         unsub();
         return;
@@ -280,10 +281,10 @@ export default class AstarNativeStakingPoolHandler extends BaseParaNativeStaking
           }
         }));
       }
-    });
+    }));
     return () => {
       cancel = true;
-      unsub();
+      unsub && unsub();
     };
   }
 

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/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>;
+}