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

package/services/swap-service/index.js

@@ -0,0 +1,241 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { ChainflipSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
+import { HydradxHandler } from '@subwallet/extension-base/services/swap-service/handler/hydradx-handler';
+import { DEFAULT_SWAP_FIRST_STEP, getSwapAltToken, MOCK_SWAP_FEE, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { _SUPPORTED_SWAP_PROVIDERS, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+export class SwapService {
+  swapPairSubject = new BehaviorSubject([]);
+  handlers = {};
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  status = ServiceStatus.NOT_INITIALIZED;
+  constructor(state) {
+    this.state = state;
+    this.eventService = state.eventService;
+    this.chainService = state.chainService;
+  }
+  async askProvidersForQuote(request) {
+    const availableQuotes = [];
+    await Promise.all(Object.values(this.handlers).map(async handler => {
+      if (handler.init && handler.isReady === false) {
+        await handler.init();
+      }
+      const quote = await handler.getSwapQuote(request);
+      if (!(quote instanceof SwapError)) {
+        availableQuotes.push({
+          quote
+        });
+      } else {
+        availableQuotes.push({
+          error: quote
+        });
+      }
+    }));
+    return availableQuotes; // todo: need to propagate error for further handling
+  }
+
+  getDefaultProcess(params) {
+    const result = {
+      totalFee: [MOCK_SWAP_FEE],
+      steps: [DEFAULT_SWAP_FIRST_STEP]
+    };
+    result.totalFee.push({
+      feeComponent: [],
+      feeOptions: [params.request.pair.from],
+      defaultFeeToken: params.request.pair.from
+    });
+    result.steps.push({
+      id: result.steps.length,
+      name: 'Swap',
+      type: SwapStepType.SWAP
+    });
+    return result;
+  }
+  async generateOptimalProcess(params) {
+    if (!params.selectedQuote) {
+      return this.getDefaultProcess(params);
+    } else {
+      const providerId = params.selectedQuote.provider.id;
+      const handler = this.handlers[providerId];
+      if (handler) {
+        return handler.generateOptimalProcess(params);
+      } else {
+        return this.getDefaultProcess(params);
+      }
+    }
+  }
+  async handleSwapRequest(request) {
+    /*
+    * 1. Ask swap quotes from providers
+    * 2. Select the best quote
+    * 3. Generate optimal process for that quote
+    * */
+
+    const swapQuoteResponse = await this.getLatestQuotes(request);
+    const optimalProcess = await this.generateOptimalProcess({
+      request,
+      selectedQuote: swapQuoteResponse.optimalQuote
+    });
+    console.log('optimalProcess', optimalProcess);
+    return {
+      process: optimalProcess,
+      quote: swapQuoteResponse
+    };
+  }
+  async getLatestQuotes(request) {
+    request.pair.metadata = this.getSwapPairMetadata(request.pair.slug); // todo: improve this
+    const quoteAskResponses = await this.askProvidersForQuote(request);
+
+    // todo: handle error to return back to UI
+    // todo: more logic to select the best quote
+
+    const availableQuotes = quoteAskResponses.filter(quote => !quote.error).map(quote => quote.quote);
+    let quoteError;
+    let selectedQuote;
+    let aliveUntil = +Date.now() + SWAP_QUOTE_TIMEOUT_MAP.default;
+    if (availableQuotes.length === 0) {
+      const preferredErrorResp = quoteAskResponses.find(quote => {
+        return !!quote.error && ![SwapErrorType.UNKNOWN, SwapErrorType.ASSET_NOT_SUPPORTED].includes(quote.error.errorType);
+      });
+      const defaultErrorResp = quoteAskResponses.find(quote => !!quote.error);
+      quoteError = (preferredErrorResp === null || preferredErrorResp === void 0 ? void 0 : preferredErrorResp.error) || (defaultErrorResp === null || defaultErrorResp === void 0 ? void 0 : defaultErrorResp.error);
+    } else {
+      var _selectedQuote;
+      selectedQuote = availableQuotes[0];
+      aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + SWAP_QUOTE_TIMEOUT_MAP.default;
+    }
+    return {
+      optimalQuote: selectedQuote,
+      quotes: availableQuotes,
+      error: quoteError,
+      aliveUntil
+    };
+  }
+  initHandlers() {
+    _SUPPORTED_SWAP_PROVIDERS.forEach(providerId => {
+      switch (providerId) {
+        case SwapProviderId.CHAIN_FLIP_TESTNET:
+          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService);
+          break;
+        case SwapProviderId.CHAIN_FLIP_MAINNET:
+          this.handlers[providerId] = new ChainflipSwapHandler(this.chainService, this.state.balanceService, false);
+          break;
+        case SwapProviderId.HYDRADX_TESTNET:
+          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService);
+          break;
+        case SwapProviderId.HYDRADX_MAINNET:
+          this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, false);
+          break;
+        default:
+          throw new Error('Unsupported provider');
+      }
+    });
+  }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    this.eventService.emit('swap.ready', true);
+    this.status = ServiceStatus.INITIALIZED;
+    this.initHandlers();
+    await this.start();
+  }
+  async start() {
+    if (this.status === ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === ServiceStatus.STARTED || this.status === ServiceStatus.STARTING) {
+      return this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+
+    // todo: start the service jobs, subscribe data,...
+
+    this.swapPairSubject.next(this.getSwapPairs()); // todo: might need to change it online
+
+    // Update promise handler
+    this.startPromiseHandler.resolve();
+    this.stopPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STARTED;
+  }
+  async stop() {
+    if (this.status === ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+      return this.waitForStopped();
+    }
+
+    // todo: unsub, persist data,...
+
+    this.stopPromiseHandler.resolve();
+    this.startPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STOPPED;
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+  getSwapPairs() {
+    return Object.entries(this.chainService.swapRefMap).map(([slug, assetRef]) => {
+      const fromAsset = this.chainService.getAssetBySlug(assetRef.srcAsset);
+      return {
+        slug,
+        from: assetRef.srcAsset,
+        to: assetRef.destAsset,
+        metadata: {
+          alternativeAsset: getSwapAltToken(fromAsset)
+        }
+      };
+    });
+  }
+  getSwapPairMetadata(slug) {
+    var _this$getSwapPairs$fi;
+    return (_this$getSwapPairs$fi = this.getSwapPairs().find(pair => pair.slug === slug)) === null || _this$getSwapPairs$fi === void 0 ? void 0 : _this$getSwapPairs$fi.metadata;
+  }
+  async validateSwapProcess(params) {
+    const providerId = params.selectedQuote.provider.id;
+    const handler = this.handlers[providerId];
+    if (handler) {
+      return handler.validateSwapProcess(params);
+    } else {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+  }
+  async handleSwapProcess(params) {
+    const handler = this.handlers[params.quote.provider.id];
+    if (params.process.steps.length === 1) {
+      // todo: do better to handle error generating steps
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Please check your network and try again'));
+    }
+    if (handler) {
+      return handler.handleSwapProcess(params);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  subscribeSwapPairs(callback) {
+    return this.chainService.subscribeSwapRefMap().subscribe(refMap => {
+      const latestData = Object.entries(refMap).map(([slug, assetRef]) => {
+        const fromAsset = this.chainService.getAssetBySlug(assetRef.srcAsset);
+        return {
+          slug,
+          from: assetRef.srcAsset,
+          to: assetRef.destAsset,
+          metadata: {
+            alternativeAsset: getSwapAltToken(fromAsset)
+          }
+        };
+      });
+      callback(latestData);
+    });
+  }
+}

package/services/swap-service/utils.d.ts

@@ -0,0 +1,18 @@
+import { Asset, Chain } from '@chainflip/sdk/swap';
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SwapErrorType, SwapFeeInfo, SwapPair, SwapStepDetail } from '@subwallet/extension-base/types/swap';
+export declare const CHAIN_FLIP_TESTNET_EXPLORER = "https://blocks-perseverance.chainflip.io";
+export declare const CHAIN_FLIP_MAINNET_EXPLORER = "https://scan.chainflip.io";
+export declare const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING: Record<string, Chain>;
+export declare const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING: Record<string, Chain>;
+export declare const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING: Record<string, Asset>;
+export declare const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, Asset>;
+export declare const SWAP_QUOTE_TIMEOUT_MAP: Record<string, number>;
+export declare const DEFAULT_SWAP_FIRST_STEP: SwapStepDetail;
+export declare const MOCK_SWAP_FEE: SwapFeeInfo;
+export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | undefined;
+export declare function getSwapAltToken(chainAsset: _ChainAsset): string | undefined;
+export declare function calculateSwapRate(fromAmount: string, toAmount: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
+export declare function getChainflipEarlyValidationError(error: SwapErrorType, metadata: ChainflipPreValidationMetadata): SwapError;
+export declare function getEarlyHydradxValidationError(error: SwapErrorType, metadata: HydradxPreValidationMetadata): SwapError;

package/services/swap-service/utils.js

@@ -0,0 +1,105 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { Assets, Chains } from '@chainflip/sdk/swap';
+import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { _getAssetDecimals } from '@subwallet/extension-base/services/chain-service/utils';
+import { SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
+export const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
+export const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
+  [COMMON_CHAIN_SLUGS.POLKADOT]: Chains.Polkadot,
+  [COMMON_CHAIN_SLUGS.ETHEREUM]: Chains.Ethereum
+};
+export const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = {
+  [COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]: Chains.Ethereum,
+  [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT]: Chains.Polkadot
+};
+export const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = {
+  [COMMON_ASSETS.DOT]: Assets.DOT,
+  [COMMON_ASSETS.ETH]: Assets.ETH,
+  [COMMON_ASSETS.USDC_ETHEREUM]: Assets.USDC
+};
+export const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
+  [COMMON_ASSETS.PDOT]: Assets.DOT,
+  [COMMON_ASSETS.ETH_SEPOLIA]: Assets.ETH,
+  [COMMON_ASSETS.USDC_SEPOLIA]: Assets.USDC
+};
+export const SWAP_QUOTE_TIMEOUT_MAP = {
+  // in milliseconds
+  default: 30000,
+  [SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
+  [SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+};
+export const DEFAULT_SWAP_FIRST_STEP = {
+  id: 0,
+  name: 'Fill information',
+  type: SwapStepType.DEFAULT
+};
+export const MOCK_SWAP_FEE = {
+  feeComponent: [],
+  defaultFeeToken: '',
+  feeOptions: []
+};
+export 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;
+}
+export function getSwapAltToken(chainAsset) {
+  var _chainAsset$metadata;
+  return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.alternativeSwapAsset;
+}
+export function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
+  const bnFromAmount = new BigN(fromAmount);
+  const bnToAmount = new BigN(toAmount);
+  const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
+  const bnRate = bnFromAmount.div(bnToAmount);
+  return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+export function getChainflipEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const parsedMinSwapValue = 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(error, message);
+      }
+    case SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          const parsedMaxSwapValue = formatNumber(metadata.maxSwap.value, metadata.maxSwap.decimals);
+          return new SwapError(error, `Amount too high. Lower your amount below ${parsedMaxSwapValue} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new SwapError(error, 'Amount too high. Lower your amount 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.');
+    default:
+      return new SwapError(error);
+  }
+}
+export function getEarlyHydradxValidationError(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.');
+    default:
+      return new SwapError(error);
+  }
+}

package/services/transaction-service/index.js

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

package/services/transaction-service/utils.d.ts

@@ -1,4 +1,6 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { ExtrinsicDataTypeMap, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainflipSwapTxData } from '@subwallet/extension-base/types/swap';
 export declare function parseTransactionData<T extends ExtrinsicType>(data: unknown): ExtrinsicDataTypeMap[T];
 export declare function getExplorerLink(chainInfo: _ChainInfo, value: string, type: 'account' | 'tx'): string | undefined;
+export declare function getChainflipExplorerLink(data: ChainflipSwapTxData, chainInfo: _ChainInfo): string;

package/services/transaction-service/utils.js

@@ -1,8 +1,8 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getBlockExplorerFromChain, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
-
+import { _getBlockExplorerFromChain, _isChainTestNet, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { CHAIN_FLIP_MAINNET_EXPLORER, CHAIN_FLIP_TESTNET_EXPLORER } from '@subwallet/extension-base/services/swap-service/utils';
 // @ts-ignore
 export function parseTransactionData(data) {
   // @ts-ignore
@@ -47,4 +47,8 @@ export function getExplorerLink(chainInfo, value, type) {
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   return undefined;
+}
+export function getChainflipExplorerLink(data, chainInfo) {
+  const chainflipDomain = _isChainTestNet(chainInfo) ? CHAIN_FLIP_TESTNET_EXPLORER : CHAIN_FLIP_MAINNET_EXPLORER;
+  return `${chainflipDomain}/channels/${data.depositChannelId}`;
 }

package/types/fee/evm.d.ts

@@ -0,0 +1,49 @@
+import BigN from 'bignumber.js';
+interface BaseFeeInfo {
+    busyNetwork: boolean;
+}
+export interface EvmLegacyFeeInfo extends BaseFeeInfo {
+    gasPrice: string;
+    maxFeePerGas: undefined;
+    maxPriorityFeePerGas: undefined;
+    baseGasFee: undefined;
+}
+export interface EvmEIP1995FeeInfo extends BaseFeeInfo {
+    gasPrice: undefined;
+    maxFeePerGas: BigN;
+    maxPriorityFeePerGas: BigN;
+    baseGasFee: BigN;
+}
+export declare type EvmFeeInfo = EvmLegacyFeeInfo | EvmEIP1995FeeInfo;
+export interface EvmLegacyFeeInfoCache extends BaseFeeInfo {
+    gasPrice: string;
+    maxFeePerGas: undefined;
+    maxPriorityFeePerGas: undefined;
+    baseGasFee: undefined;
+}
+export interface EvmEIP1995FeeInfoCache extends BaseFeeInfo {
+    gasPrice: undefined;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    baseGasFee: string;
+}
+export declare type EvmFeeInfoCache = EvmLegacyFeeInfoCache | EvmEIP1995FeeInfoCache;
+export interface InfuraFeeDetail {
+    suggestedMaxPriorityFeePerGas: string;
+    suggestedMaxFeePerGas: string;
+    minWaitTimeEstimate: number;
+    maxWaitTimeEstimate: number;
+}
+export interface InfuraFeeInfo {
+    low: InfuraFeeDetail;
+    medium: InfuraFeeDetail;
+    high: InfuraFeeDetail;
+    networkCongestion: number;
+    estimatedBaseFee: string;
+    latestPriorityFeeRange: [string, string];
+    historicalPriorityFeeRange: [string, string];
+    historicalBaseFeeRange: [string, string];
+    priorityFeeTrend: 'down' | 'up';
+    baseFeeTrend: 'down' | 'up';
+}
+export {};

package/types/fee/evm.js

@@ -0,0 +1 @@
+export {};

package/types/fee/fee.d.ts

@@ -0,0 +1,32 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+export declare enum SWFeeType {
+    EIP_1559 = "EIP_1559",
+    LEGACY = "LEGACY",
+    SUBSTRATE = "SUBSTRATE"
+}
+export interface FeeOption {
+    tokenInfo: _ChainAsset;
+    isDefault: boolean;
+    amount?: string;
+    type: SWFeeType;
+    metadata?: any;
+}
+export interface MultiFee {
+    feeOptions: FeeOption[];
+    totalFeeValue?: number;
+}
+export declare class SWFee {
+    chain: string;
+    feeOptions: FeeOption[];
+    private _selectedFeeOption?;
+    private _transactionId?;
+    get transactionId(): string | undefined;
+    get selectedFeeOption(): FeeOption | undefined;
+    static build(feeOptions: FeeOption[], chain: string, selectedFeeOption?: FeeOption): SWFee;
+    static buildSimpleFee(tokenInfo: _ChainAsset, amount: string, type: SWFeeType): SWFee;
+    static buildFeeOption(tokenInfo: _ChainAsset, amount: string, type: SWFeeType): FeeOption;
+    setTransactionId(transactionId: string): void;
+    setSelectedFeeOption(feeOption: FeeOption): void;
+    constructor(feeOptions: FeeOption[], chain: string, selectedFeeOption?: FeeOption);
+    getDefaultFeeOption(): FeeOption;
+}

package/types/fee/fee.js

@@ -0,0 +1,63 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+export let SWFeeType;
+(function (SWFeeType) {
+  SWFeeType["EIP_1559"] = "EIP_1559";
+  SWFeeType["LEGACY"] = "LEGACY";
+  SWFeeType["SUBSTRATE"] = "SUBSTRATE";
+})(SWFeeType || (SWFeeType = {}));
+export 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: _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: _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);
+  }
+}

package/types/fee/index.d.ts

@@ -1,49 +1,2 @@
-import BigN from 'bignumber.js';
-interface BaseFeeInfo {
-    busyNetwork: boolean;
-}
-export interface EvmLegacyFeeInfo extends BaseFeeInfo {
-    gasPrice: string;
-    maxFeePerGas: undefined;
-    maxPriorityFeePerGas: undefined;
-    baseGasFee: undefined;
-}
-export interface EvmEIP1995FeeInfo extends BaseFeeInfo {
-    gasPrice: undefined;
-    maxFeePerGas: BigN;
-    maxPriorityFeePerGas: BigN;
-    baseGasFee: BigN;
-}
-export declare type EvmFeeInfo = EvmLegacyFeeInfo | EvmEIP1995FeeInfo;
-export interface EvmLegacyFeeInfoCache extends BaseFeeInfo {
-    gasPrice: string;
-    maxFeePerGas: undefined;
-    maxPriorityFeePerGas: undefined;
-    baseGasFee: undefined;
-}
-export interface EvmEIP1995FeeInfoCache extends BaseFeeInfo {
-    gasPrice: undefined;
-    maxFeePerGas: string;
-    maxPriorityFeePerGas: string;
-    baseGasFee: string;
-}
-export declare type EvmFeeInfoCache = EvmLegacyFeeInfoCache | EvmEIP1995FeeInfoCache;
-export interface InfuraFeeDetail {
-    suggestedMaxPriorityFeePerGas: string;
-    suggestedMaxFeePerGas: string;
-    minWaitTimeEstimate: number;
-    maxWaitTimeEstimate: number;
-}
-export interface InfuraFeeInfo {
-    low: InfuraFeeDetail;
-    medium: InfuraFeeDetail;
-    high: InfuraFeeDetail;
-    networkCongestion: number;
-    estimatedBaseFee: string;
-    latestPriorityFeeRange: [string, string];
-    historicalPriorityFeeRange: [string, string];
-    historicalBaseFeeRange: [string, string];
-    priorityFeeTrend: 'down' | 'up';
-    baseFeeTrend: 'down' | 'up';
-}
-export {};
+export * from './evm';
+export * from './fee';

package/types/fee/index.js

@@ -1 +1,5 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./evm.js";
+export * from "./fee.js";

package/types/service-base.d.ts

@@ -0,0 +1,10 @@
+import { OptimalSwapPath, OptimalSwapPathParams, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { OptimalYieldPath, OptimalYieldPathParams, YieldStepType } from '@subwallet/extension-base/types/yield';
+export declare type OptimalProcessParams = OptimalYieldPathParams | OptimalSwapPathParams;
+export declare type OptimalProcessResult = OptimalYieldPath | OptimalSwapPath;
+export declare type BaseStepType = SwapStepType | YieldStepType;
+export interface BaseStepDetail {
+    type: BaseStepType;
+    name: string;
+    metadata?: Record<string, unknown>;
+}

package/types/service-base.js

@@ -0,0 +1 @@
+export {};