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

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

@@ -0,0 +1,531 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HydradxHandler = void 0;
+var _sdk = require("@galacticcouncil/sdk");
+var _chainList = require("@subwallet/chain-list");
+var _types = require("@subwallet/chain-list/types");
+var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _xcm = require("@subwallet/extension-base/koni/api/xcm");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const 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';
+class HydradxHandler {
+  isTestnet = true;
+  isReady = false;
+  constructor(chainService, balanceService) {
+    let isTestnet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      balanceService,
+      chainService,
+      providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
+      providerSlug: isTestnet ? _swap.SwapProviderId.HYDRADX_TESTNET : _swap.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 _sdk.PoolService(substrateApi.api);
+    this.tradeRouter = new _sdk.TradeRouter(poolService);
+    this.isReady = true;
+  }
+  chain = () => {
+    // TODO: check origin chain of tokens in swap pair to determine support
+    if (!this.isTestnet) {
+      return _chainList.COMMON_CHAIN_SLUGS.HYDRADX;
+    } else {
+      return _chainList.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.default(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.default(fromAssetBalance.value);
+    if (bnFromAssetBalance.gte(bnAmount)) {
+      return undefined; // enough balance, no need to xcm
+    }
+
+    const alternativeAssetSlug = (0, _utils2.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.default(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: _swap.SwapStepType.XCM
+      };
+      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const xcmTransfer = await (0, _xcm.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: _swap.SwapFeeType.NETWORK_FEE,
+          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
+        }],
+        defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo),
+        feeOptions: [(0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)]
+      };
+      return [step, fee];
+    } catch (e) {
+      return undefined;
+    }
+  }
+  async getFeeOptionStep(params) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const selectedFeeToken = params.selectedQuote.feeInfo.selectedFeeToken;
+    if (!selectedFeeToken) {
+      return undefined;
+    }
+    const feeStep = {
+      name: 'Set fee token',
+      type: _swap.SwapStepType.SET_FEE_TOKEN
+    };
+    try {
+      const substrateApi = this.chainService.getSubstrateApi(this.chain());
+      const chainApi = await substrateApi.isReady;
+      const _currentFeeAssetId = await chainApi.api.query.multiTransactionPayment.accountCurrencyMap(params.request.address);
+      const currentFeeAssetId = _currentFeeAssetId.toString();
+      const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeToken);
+      const assetId = (0, _utils._getTokenOnChainAssetId)(selectedFeeAsset);
+      if (currentFeeAssetId === assetId) {
+        return;
+      }
+      const setFeeTx = chainApi.api.tx.multiTransactionPayment.setCurrency(assetId);
+      const _txFee = await setFeeTx.paymentInfo(params.request.address);
+      const txFee = _txFee.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: _swap.SwapFeeType.NETWORK_FEE,
+          amount: Math.round(txFee.partialFee).toString(),
+          tokenSlug: selectedFeeAsset.slug
+        }],
+        selectedFeeToken: selectedFeeAsset.slug,
+        defaultFeeToken: selectedFeeAsset.slug,
+        feeOptions: [selectedFeeAsset.slug]
+      };
+      return [feeStep, fee];
+    } catch (e) {
+      return undefined;
+    }
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: _swap.SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep,
+    // this.getFeeOptionStep.bind(this),
+    this.getSubmitStep]);
+  }
+  getSwapPathErrors(swapList) {
+    return swapList.reduce((prev, current) => {
+      return [...prev, ...current.errors];
+    }, []);
+  }
+  parseSwapPath(swapList) {
+    const swapAssets = this.chainService.getAssetByChainAndType(this.chain(), [_types._AssetType.NATIVE, _types._AssetType.LOCAL]);
+    const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
+      return {
+        ...accumulator,
+        [(0, _utils._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 = (0, _utils._getChainNativeTokenSlug)(fromChain);
+    if (!this.isReady || !this.tradeRouter) {
+      return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
+    }
+    const earlyValidation = await this.validateSwapRequest(request);
+    if (earlyValidation.error) {
+      const metadata = earlyValidation.metadata;
+      return (0, _utils2.getEarlyHydradxValidationError)(earlyValidation.error, metadata);
+    }
+    try {
+      const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
+      const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
+      const parsedFromAmount = new _bignumber.default(request.fromAmount).shiftedBy(-1 * (0, _utils._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: _swap.SwapFeeType.NETWORK_FEE
+      };
+      const tradeFee = {
+        tokenSlug: toAsset.slug,
+        // fee is subtracted from receiving amount
+        amount: quoteResponse.tradeFee.toString(),
+        feeType: _swap.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 _sdk.PoolError.InsufficientTradingAmount:
+            return new _SwapError.SwapError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE);
+          case _sdk.PoolError.TradeNotAllowed:
+            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+          case _sdk.PoolError.MaxInRatioExceeded:
+            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+          case _sdk.PoolError.UnknownError:
+            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+          case _sdk.PoolError.MaxOutRatioExceeded:
+            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+        }
+      }
+
+      // const feeTokenOptions = this.chainService.getFeeTokensByChain(this.chain());
+      const feeTokenOptions = [fromChainNativeTokenSlug];
+
+      // if (request.feeToken && !feeTokenOptions.includes(request.feeToken)) {
+      //   return new SwapError(SwapErrorType.UNKNOWN);
+      // }
+
+      // const selectedFeeToken = request.feeToken || fromChainNativeTokenSlug;
+      const selectedFeeToken = fromChainNativeTokenSlug;
+      return {
+        pair: request.pair,
+        fromAmount: request.fromAmount,
+        toAmount: toAmount.toString(),
+        rate: (0, _utils2.calculateSwapRate)(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
+        feeInfo: {
+          feeComponent: [networkFee, tradeFee],
+          defaultFeeToken: fromChainNativeTokenSlug,
+          feeOptions: feeTokenOptions,
+          // TODO: enable fee options
+          selectedFeeToken
+        },
+        isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
+        route: swapRoute,
+        metadata: txHex
+      };
+    } catch (e) {
+      return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+  async handleXcmStep(params) {
+    const pair = params.quote.pair;
+    const alternativeAssetSlug = (0, _utils2.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.default(params.quote.fromAmount);
+    const bnDestinationAssetBalance = new _bignumber.default(destinationAssetBalance.value);
+    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
+    if ((0, _utils._isNativeToken)(originAsset)) {
+      const bnXcmFee = new _bignumber.default(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 (0, _xcm.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: (0, _utils._isNativeToken)(originAsset) ? bnTotalAmount.toString() : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      txData: xcmData
+    };
+  }
+  async handleSetFeeStep(params) {
+    var _swapFeeInfo$selected;
+    const substrateApi = this.chainService.getSubstrateApi(this.chain());
+    const chainApi = await substrateApi.isReady;
+    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap.SwapStepType.SWAP);
+    if (swapStepIndex <= -1) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const swapFeeInfo = params.process.totalFee[swapStepIndex];
+    const selectedFeeTokenSlug = (_swapFeeInfo$selected = swapFeeInfo.selectedFeeToken) !== null && _swapFeeInfo$selected !== void 0 ? _swapFeeInfo$selected : swapFeeInfo.defaultFeeToken;
+    const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeTokenSlug);
+    const extrinsic = chainApi.api.tx.multiTransactionPayment.setCurrency((0, _utils._getTokenOnChainAssetId)(selectedFeeAsset));
+    const txData = {
+      selectedFeeToken: selectedFeeTokenSlug
+    };
+    return {
+      txChain: this.chain(),
+      extrinsic,
+      // extrinsicType: ExtrinsicType.SET_FEE_TOKEN,
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      txData
+    };
+  }
+  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 txList = [];
+    const swapTx = chainApi.api.tx(txHex);
+    const _referral = await chainApi.api.query.referrals.linkedAccounts(params.address);
+    const referral = _referral === null || _referral === void 0 ? void 0 : _referral.toString();
+    const needSetReferral = !referral || referral === '';
+    const steps = params.process.steps.map(step => step.type);
+    const needSetFeeToken = steps.includes(_swap.SwapStepType.SET_FEE_TOKEN);
+    if (!needSetReferral && !needSetFeeToken) {
+      extrinsic = swapTx;
+    } else {
+      if (needSetReferral) {
+        txList.push(chainApi.api.tx.referrals.linkCode(this.referralCode));
+      }
+      if (needSetFeeToken) {
+        const nativeTokenInfo = this.chainService.getNativeTokenInfo(this.chain());
+        txList.push(chainApi.api.tx.multiTransactionPayment.setCurrency((0, _utils._getTokenOnChainAssetId)(nativeTokenInfo)));
+      }
+      txList.push(swapTx);
+      extrinsic = chainApi.api.tx.utility.batchAll(txList);
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      // todo
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+  handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _swap.SwapStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+      case _swap.SwapStepType.XCM:
+        return this.handleXcmStep(params);
+      case _swap.SwapStepType.SET_FEE_TOKEN:
+        return this.handleSetFeeStep(params);
+      case _swap.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = new _bignumber.default(amount);
+    if (bnAmount.lte(0)) {
+      return [new _TransactionError.TransactionError(_KoniTypes.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 _swap.SwapStepType.DEFAULT:
+            return Promise.resolve([]);
+          case _swap.SwapStepType.XCM:
+            return this.swapBaseHandler.validateXcmStep(params, index);
+          case _swap.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 === _swap.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 = (0, _utils._getTokenOnChainAssetId)(fromAsset);
+    const toAssetId = (0, _utils._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: _swap.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: _swap.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: _swap.SwapErrorType.UNKNOWN
+        };
+      }
+      const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
+      if (!pairedToAsset) {
+        return {
+          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
+        };
+      }
+      if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
+        return {
+          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
+        };
+      }
+      if (!fromAssetId || !toAssetId) {
+        return {
+          error: _swap.SwapErrorType.UNKNOWN
+        };
+      }
+      const bnAmount = new _bignumber.default(request.fromAmount);
+      if (bnAmount.lte(0)) {
+        return {
+          error: _swap.SwapErrorType.AMOUNT_CANNOT_BE_ZERO
+        };
+      }
+      return {
+        metadata: {
+          chain: this.chainService.getChainInfoByKey(this.chain())
+        }
+      };
+    } catch (e) {
+      return {
+        error: _swap.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;
+  }
+}
+exports.HydradxHandler = HydradxHandler;