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

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

@@ -1,435 +0,0 @@
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-
-import { PoolError, PoolService, TradeRouter } from '@galacticcouncil/sdk';
-import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { _AssetType } from '@subwallet/chain-list/types';
-import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
-import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { createXcmExtrinsic } from '@subwallet/extension-base/koni/api/xcm';
-import { _getAssetDecimals, _getChainNativeTokenSlug, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { calculateSwapRate, getEarlyHydradxValidationError, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
-import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
-import BigNumber from 'bignumber.js';
-const HYDRADX_LOW_LIQUIDITY_THRESHOLD = 0.15;
-const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
-const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a';
-const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
-const HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT = '7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ';
-export class HydradxHandler {
-  isReady = false;
-  constructor(chainService, balanceService, isTestnet = true) {
-    // todo: pass in baseHandler from service
-    this.swapBaseHandler = new SwapBaseHandler({
-      balanceService,
-      chainService,
-      providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
-      providerSlug: isTestnet ? SwapProviderId.HYDRADX_TESTNET : SwapProviderId.HYDRADX_MAINNET
-    });
-    this.isTestnet = isTestnet;
-  }
-  async init() {
-    const chainState = this.chainService.getChainStateByKey(this.chain);
-    if (!chainState.active) {
-      await this.chainService.enableChain(this.chain);
-    }
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
-    await substrateApi.api.isReady;
-    const poolService = new PoolService(substrateApi.api);
-    this.tradeRouter = new TradeRouter(poolService);
-    this.isReady = true;
-  }
-  get chain() {
-    // TODO: check origin chain of tokens in swap pair to determine support
-    if (!this.isTestnet) {
-      return COMMON_CHAIN_SLUGS.HYDRADX;
-    } else {
-      return COMMON_CHAIN_SLUGS.HYDRADX_TESTNET;
-    }
-  }
-  get chainService() {
-    return this.swapBaseHandler.chainService;
-  }
-  get balanceService() {
-    return this.swapBaseHandler.balanceService;
-  }
-  get providerInfo() {
-    return this.swapBaseHandler.providerInfo;
-  }
-  get name() {
-    return this.swapBaseHandler.name;
-  }
-  get slug() {
-    return this.swapBaseHandler.slug;
-  }
-  async getXcmStep(params) {
-    const bnAmount = new BigNumber(params.request.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
-    const fromAssetBalance = await this.balanceService.getTokenFreeBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
-    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
-    if (bnFromAssetBalance.gte(bnAmount)) {
-      return undefined; // enough balance, no need to xcm
-    }
-
-    const alternativeAssetSlug = getSwapAlternativeAsset(params.request.pair);
-    if (!alternativeAssetSlug) {
-      return undefined;
-    }
-    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const alternativeAssetBalance = await this.balanceService.getTokenFreeBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
-    const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
-    if (bnAlternativeAssetBalance.lte(0)) {
-      return undefined;
-    }
-    try {
-      const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
-      const step = {
-        metadata: {
-          sendingValue: bnAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: SwapStepType.XCM
-      };
-      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
-      const xcmTransfer = await createXcmExtrinsic({
-        originTokenInfo: alternativeAsset,
-        destinationTokenInfo: fromAsset,
-        sendingValue: bnAmount.toString(),
-        recipient: params.request.address,
-        chainInfoMap: this.chainService.getChainInfoMap(),
-        substrateApi: xcmOriginSubstrateApi
-      });
-      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
-      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
-      const fee = {
-        feeComponent: [{
-          feeType: SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
-          tokenSlug: _getChainNativeTokenSlug(alternativeChainInfo)
-        }],
-        defaultFeeToken: _getChainNativeTokenSlug(alternativeChainInfo),
-        feeOptions: [_getChainNativeTokenSlug(alternativeChainInfo)]
-      };
-      return [step, fee];
-    } catch (e) {
-      return undefined;
-    }
-  }
-  async getFeeOptionStep(params) {
-    return Promise.resolve(undefined);
-  }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getFeeOptionStep, this.getSubmitStep]);
-  }
-  getSwapPathErrors(swapList) {
-    return swapList.reduce((prev, current) => {
-      return [...prev, ...current.errors];
-    }, []);
-  }
-  parseSwapPath(swapList) {
-    const swapAssets = this.chainService.getAssetByChainAndType(this.chain, [_AssetType.NATIVE, _AssetType.LOCAL]);
-    const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
-      return {
-        ...accumulator,
-        [_getTokenOnChainAssetId(asset)]: asset
-      };
-    }, {});
-    const path = [];
-    swapList.forEach(swap => {
-      var _swapAssetIdMap$swap$, _swapAssetIdMap$swap$2;
-      const swapAssetIn = (_swapAssetIdMap$swap$ = swapAssetIdMap[swap.assetIn]) === null || _swapAssetIdMap$swap$ === void 0 ? void 0 : _swapAssetIdMap$swap$.slug;
-      const swapAssetOut = (_swapAssetIdMap$swap$2 = swapAssetIdMap[swap.assetOut]) === null || _swapAssetIdMap$swap$2 === void 0 ? void 0 : _swapAssetIdMap$swap$2.slug;
-      if (swapAssetIn && !path.includes(swapAssetIn)) {
-        path.push(swapAssetIn);
-      }
-      if (swapAssetOut && !path.includes(swapAssetOut)) {
-        path.push(swapAssetOut);
-      }
-    });
-    return {
-      path
-    };
-  }
-  async getSwapQuote(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const fromChainNativeTokenSlug = _getChainNativeTokenSlug(fromChain);
-    if (!this.isReady || !this.tradeRouter) {
-      return new SwapError(SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return getEarlyHydradxValidationError(earlyValidation.error, metadata);
-    }
-    try {
-      const fromAssetId = _getTokenOnChainAssetId(fromAsset);
-      const toAssetId = _getTokenOnChainAssetId(toAsset);
-      const parsedFromAmount = new BigNumber(request.fromAmount).shiftedBy(-1 * _getAssetDecimals(fromAsset)).toString();
-      const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
-      const toAmount = quoteResponse.amountOut;
-      const minReceive = toAmount.times(1 - request.slippage).integerValue();
-      const txHex = quoteResponse.toTx(minReceive).hex;
-      const substrateApi = this.chainService.getSubstrateApi(this.chain);
-      const extrinsic = substrateApi.api.tx(txHex);
-      const paymentInfo = await extrinsic.paymentInfo(request.address);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: paymentInfo.partialFee.toString(),
-        feeType: SwapFeeType.NETWORK_FEE
-      };
-      const tradeFee = {
-        tokenSlug: toAsset.slug,
-        // fee is subtracted from receiving amount
-        amount: quoteResponse.tradeFee.toString(),
-        feeType: SwapFeeType.PLATFORM_FEE
-      };
-      const swapRoute = this.parseSwapPath(quoteResponse.swaps);
-      const swapPathErrors = this.getSwapPathErrors(quoteResponse.swaps);
-      if (swapPathErrors.length > 0) {
-        const defaultError = swapPathErrors[0]; // might parse more errors
-
-        switch (defaultError) {
-          case PoolError.InsufficientTradingAmount:
-            return new SwapError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE);
-          case PoolError.TradeNotAllowed:
-            return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-          case PoolError.MaxInRatioExceeded:
-            return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-          case PoolError.UnknownError:
-            return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-          case PoolError.MaxOutRatioExceeded:
-            return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-        }
-      }
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: toAmount.toString(),
-        rate: calculateSwapRate(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
-        feeInfo: {
-          feeComponent: [networkFee, tradeFee],
-          defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: [fromChainNativeTokenSlug] // todo: parse fee options
-        },
-
-        isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
-        route: swapRoute,
-        metadata: txHex
-      };
-    } catch (e) {
-      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
-  async handleXcmStep(params) {
-    const pair = params.quote.pair;
-    const alternativeAssetSlug = getSwapAlternativeAsset(pair);
-    const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const destinationAsset = this.chainService.getAssetBySlug(pair.from);
-    const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
-    const chainApi = await substrateApi.isReady;
-    const destinationAssetBalance = await this.balanceService.getTokenFreeBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
-    const xcmFee = params.process.totalFee[params.currentStep];
-    const bnAmount = new BigNumber(params.quote.fromAmount);
-    const bnDestinationAssetBalance = new BigNumber(destinationAssetBalance.value);
-    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
-    if (_isNativeToken(originAsset)) {
-      const bnXcmFee = new BigNumber(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-      bnTotalAmount = bnTotalAmount.plus(bnXcmFee);
-    }
-    const xcmTransfer = await createXcmExtrinsic({
-      originTokenInfo: originAsset,
-      destinationTokenInfo: destinationAsset,
-      sendingValue: bnTotalAmount.toString(),
-      recipient: params.address,
-      chainInfoMap: this.chainService.getChainInfoMap(),
-      substrateApi: chainApi
-    });
-    const xcmData = {
-      originNetworkKey: originAsset.originChain,
-      destinationNetworkKey: destinationAsset.originChain,
-      from: params.address,
-      to: params.address,
-      value: bnTotalAmount.toString(),
-      tokenSlug: originAsset.slug,
-      showExtraWarning: true
-    };
-    return {
-      txChain: originAsset.originChain,
-      extrinsic: xcmTransfer,
-      transferNativeAmount: _isNativeToken(originAsset) ? bnTotalAmount.toString() : '0',
-      extrinsicType: ExtrinsicType.TRANSFER_XCM,
-      chainType: ChainType.SUBSTRATE,
-      txData: xcmData
-    };
-  }
-  async handleSubmitStep(params) {
-    const txHex = params.quote.metadata;
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
-    const chainApi = await substrateApi.isReady;
-    const txData = {
-      provider: this.providerInfo,
-      quote: params.quote,
-      address: params.address,
-      slippage: params.slippage,
-      txHex,
-      process: params.process
-    };
-    let extrinsic;
-    const _referral = await chainApi.api.query.referrals.linkedAccounts(params.address);
-    const referral = _referral === null || _referral === void 0 ? void 0 : _referral.toString();
-    if (!referral || referral === '') {
-      extrinsic = chainApi.api.tx.utility.batchAll([chainApi.api.tx.referrals.linkCode(this.referralCode), chainApi.api.tx(txHex)]);
-    } else {
-      extrinsic = chainApi.api.tx(txHex);
-    }
-    return {
-      txChain: fromAsset.originChain,
-      txData,
-      extrinsic,
-      transferNativeAmount: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
-      // todo
-      extrinsicType: ExtrinsicType.SWAP,
-      chainType: ChainType.SUBSTRATE
-    };
-  }
-  handleSwapProcess(params) {
-    const {
-      currentStep,
-      process
-    } = params;
-    const type = process.steps[currentStep].type;
-    switch (type) {
-      case SwapStepType.DEFAULT:
-        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
-      case SwapStepType.XCM:
-        return this.handleXcmStep(params);
-      case SwapStepType.SET_FEE_TOKEN:
-        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
-      case SwapStepType.SWAP:
-        return this.handleSubmitStep(params);
-      default:
-        return this.handleSubmitStep(params);
-    }
-  }
-  async validateSwapProcess(params) {
-    const amount = params.selectedQuote.fromAmount;
-    const bnAmount = new BigNumber(amount);
-    if (bnAmount.lte(0)) {
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
-    }
-    let isXcmOk = false;
-    for (const [index, step] of params.process.steps.entries()) {
-      const getErrors = async () => {
-        switch (step.type) {
-          case SwapStepType.DEFAULT:
-            return Promise.resolve([]);
-          case SwapStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
-          case SwapStepType.SET_FEE_TOKEN:
-            return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === SwapStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
-  async validateSwapRequest(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromAssetId = _getTokenOnChainAssetId(fromAsset);
-    const toAssetId = _getTokenOnChainAssetId(toAsset);
-    try {
-      var _this$tradeRouter, _this$tradeRouter2;
-      // todo: might need to optimize for performance, but prioritize safety for now
-      const allAssets = await ((_this$tradeRouter = this.tradeRouter) === null || _this$tradeRouter === void 0 ? void 0 : _this$tradeRouter.getAllAssets());
-      if (!allAssets) {
-        return {
-          error: SwapErrorType.UNKNOWN
-        };
-      }
-      const supportedFromAsset = allAssets.find(asset => asset.id === fromAssetId && asset.symbol === fromAsset.symbol);
-      const supportedToAsset = allAssets.find(asset => asset.id === toAssetId && asset.symbol === toAsset.symbol);
-      if (!supportedFromAsset || !supportedToAsset) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      const assetPairs = await ((_this$tradeRouter2 = this.tradeRouter) === null || _this$tradeRouter2 === void 0 ? void 0 : _this$tradeRouter2.getAssetPairs(fromAssetId));
-      if (!assetPairs) {
-        return {
-          error: SwapErrorType.UNKNOWN
-        };
-      }
-      const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
-      if (!pairedToAsset) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!(fromAsset.originChain === this.chain && toAsset.originChain === this.chain)) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!fromAssetId || !toAssetId) {
-        return {
-          error: SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new BigNumber(request.fromAmount);
-      if (bnAmount.lte(0)) {
-        return {
-          error: SwapErrorType.AMOUNT_CANNOT_BE_ZERO
-        };
-      }
-      return {
-        metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain)
-        }
-      };
-    } catch (e) {
-      return {
-        error: SwapErrorType.UNKNOWN
-      };
-    }
-  }
-  get referralCode() {
-    if (this.isTestnet) {
-      return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;
-    }
-    return HYDRADX_SUBWALLET_REFERRAL_CODE;
-  }
-  get referralAccount() {
-    if (this.isTestnet) {
-      return HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT;
-    }
-    return HYDRADX_SUBWALLET_REFERRAL_ACCOUNT;
-  }
-}

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

@@ -1,32 +0,0 @@
-import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { ServiceStatus, ServiceWithProcessInterface, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
-import { OptimalSwapPath, OptimalSwapPathParams, SwapPair, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
-import { PromiseHandler } from '@subwallet/extension-base/utils';
-export declare class SwapService implements ServiceWithProcessInterface, StoppableServiceInterface {
-    protected readonly state: KoniState;
-    private eventService;
-    private readonly chainService;
-    private swapPairSubject;
-    private handlers;
-    startPromiseHandler: PromiseHandler<void>;
-    stopPromiseHandler: PromiseHandler<void>;
-    status: ServiceStatus;
-    constructor(state: KoniState);
-    private askProvidersForQuote;
-    private getDefaultProcess;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
-    handleSwapRequest(request: SwapRequest): Promise<SwapRequestResult>;
-    getLatestQuotes(request: SwapRequest): Promise<SwapQuoteResponse>;
-    private initHandlers;
-    init(): Promise<void>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    waitForStarted(): Promise<void>;
-    waitForStopped(): Promise<void>;
-    getSwapPairs(): SwapPair[];
-    private getSwapPairMetadata;
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
-    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
-    subscribeSwapPairs(callback: (pairs: SwapPair[]) => void): import("rxjs").Subscription;
-}