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

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

@@ -1,407 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ChainflipSwapHandler = void 0;
-var _swap = require("@chainflip/sdk/swap");
-var _chainList = require("@subwallet/chain-list");
-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 _transfer = require("@subwallet/extension-base/koni/api/dotsama/transfer");
-var _transfer2 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
-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 _swap2 = require("@subwallet/extension-base/types/swap");
-var _bignumber = _interopRequireDefault(require("bignumber.js"));
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-var ChainflipFeeType;
-(function (ChainflipFeeType) {
-  ChainflipFeeType["INGRESS"] = "INGRESS";
-  ChainflipFeeType["NETWORK"] = "NETWORK";
-  ChainflipFeeType["EGRESS"] = "EGRESS";
-  ChainflipFeeType["LIQUIDITY"] = "LIQUIDITY";
-})(ChainflipFeeType || (ChainflipFeeType = {}));
-const INTERMEDIARY_MAINNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_ETHEREUM;
-const INTERMEDIARY_TESTNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_SEPOLIA;
-var CHAINFLIP_QUOTE_ERROR;
-(function (CHAINFLIP_QUOTE_ERROR) {
-  CHAINFLIP_QUOTE_ERROR["InsufficientLiquidity"] = "InsufficientLiquidity";
-  CHAINFLIP_QUOTE_ERROR["InsufficientEgress"] = "is lower than minimum egress amount";
-  CHAINFLIP_QUOTE_ERROR["InsufficientIngress"] = "amount is lower than estimated ingress fee";
-})(CHAINFLIP_QUOTE_ERROR || (CHAINFLIP_QUOTE_ERROR = {}));
-class ChainflipSwapHandler {
-  constructor(chainService, balanceService) {
-    let isTestnet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
-      chainService,
-      balanceService,
-      providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
-      providerSlug: isTestnet ? _swap2.SwapProviderId.CHAIN_FLIP_TESTNET : _swap2.SwapProviderId.CHAIN_FLIP_MAINNET
-    });
-    this.isTestnet = isTestnet;
-    this.swapSdk = new _swap.SwapSDK({
-      network: isTestnet ? 'perseverance' : 'mainnet'
-    });
-  }
-  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;
-  }
-  get assetMapping() {
-    if (this.isTestnet) {
-      return _utils2.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
-    } else {
-      return _utils2.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
-    }
-  }
-  get chainMapping() {
-    if (this.isTestnet) {
-      return _utils2.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
-    } else {
-      return _utils2.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
-    }
-  }
-  get intermediaryAssetSlug() {
-    if (this.isTestnet) {
-      return INTERMEDIARY_TESTNET_ASSET_SLUG;
-    } else {
-      return INTERMEDIARY_MAINNET_ASSET_SLUG;
-    }
-  }
-  async validateSwapRequest(request) {
-    try {
-      // todo: risk of matching wrong chain, asset can lead to loss of funds
-
-      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-      const srcChain = fromAsset.originChain;
-      const destChain = toAsset.originChain;
-      const srcChainInfo = this.chainService.getChainInfoByKey(srcChain);
-      const srcChainId = this.chainMapping[srcChain];
-      const destChainId = this.chainMapping[destChain];
-      const fromAssetId = this.assetMapping[fromAsset.slug];
-      const toAssetId = this.assetMapping[toAsset.slug];
-      if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
-        return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      const [supportedDestChains, srcAssets, destAssets] = await Promise.all([this.swapSdk.getChains(srcChainId), this.swapSdk.getAssets(srcChainId), this.swapSdk.getAssets(destChainId)]);
-      const supportedDestChainId = supportedDestChains.find(c => c.chain === destChainId);
-      const srcAssetData = srcAssets.find(a => a.asset === fromAssetId);
-      const destAssetData = destAssets.find(a => a.asset === toAssetId);
-      if (!destAssetData || !srcAssetData || !supportedDestChainId) {
-        return {
-          error: _swap2.SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new _bignumber.default(request.fromAmount);
-      const bnMinSwap = new _bignumber.default(srcAssetData.minimumSwapAmount);
-      if (srcAssetData.maximumSwapAmount) {
-        const bnMaxProtocolSwap = new _bignumber.default(srcAssetData.maximumSwapAmount);
-        if (bnMinSwap.gte(bnMaxProtocolSwap)) {
-          return {
-            error: _swap2.SwapErrorType.UNKNOWN
-          };
-        }
-        if (bnAmount.gte(bnMaxProtocolSwap)) {
-          return {
-            error: _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
-            metadata: {
-              minSwap: {
-                value: srcAssetData.minimumSwapAmount,
-                decimals: (0, _utils._getAssetDecimals)(fromAsset),
-                symbol: fromAsset.symbol
-              },
-              maxSwap: {
-                value: bnMaxProtocolSwap.toString(),
-                decimals: (0, _utils._getAssetDecimals)(fromAsset),
-                symbol: fromAsset.symbol
-              },
-              chain: srcChainInfo
-            }
-          };
-        }
-      }
-      if (bnAmount.lt(bnMinSwap)) {
-        // might miss case when minSwap is 0
-        return {
-          error: _swap2.SwapErrorType.NOT_MEET_MIN_SWAP,
-          metadata: {
-            minSwap: {
-              value: srcAssetData.minimumSwapAmount,
-              decimals: (0, _utils._getAssetDecimals)(fromAsset),
-              symbol: fromAsset.symbol
-            },
-            maxSwap: {
-              value: srcAssetData.maximumSwapAmount,
-              decimals: (0, _utils._getAssetDecimals)(fromAsset),
-              symbol: fromAsset.symbol
-            },
-            chain: srcChainInfo
-          }
-        };
-      }
-      return {
-        metadata: {
-          minSwap: {
-            value: srcAssetData.minimumSwapAmount,
-            decimals: (0, _utils._getAssetDecimals)(fromAsset),
-            symbol: fromAsset.symbol
-          },
-          maxSwap: {
-            value: srcAssetData.maximumSwapAmount,
-            decimals: (0, _utils._getAssetDecimals)(fromAsset),
-            symbol: fromAsset.symbol
-          },
-          chain: srcChainInfo
-        }
-      };
-    } catch (e) {
-      return {
-        error: _swap2.SwapErrorType.UNKNOWN
-      };
-    }
-  }
-  parseSwapPath(fromAsset, toAsset) {
-    if (toAsset.slug !== this.intermediaryAssetSlug && fromAsset.slug !== this.intermediaryAssetSlug) {
-      // Chainflip always use USDC as intermediary
-      return [fromAsset.slug, this.intermediaryAssetSlug, toAsset.slug]; // todo: generalize this
-    }
-
-    return [fromAsset.slug, toAsset.slug];
-  }
-  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 (!fromAsset || !toAsset) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    const metadata = earlyValidation.metadata;
-    if (earlyValidation.error) {
-      return (0, _utils2.getChainflipEarlyValidationError)(earlyValidation.error, metadata);
-    }
-    const srcChainId = this.chainMapping[fromAsset.originChain];
-    const destChainId = this.chainMapping[toAsset.originChain];
-    const fromAssetId = this.assetMapping[fromAsset.slug];
-    const toAssetId = this.assetMapping[toAsset.slug];
-    try {
-      var _metadata$maxSwap;
-      const quoteResponse = await this.swapSdk.getQuote({
-        srcChain: srcChainId,
-        destChain: destChainId,
-        srcAsset: fromAssetId,
-        destAsset: toAssetId,
-        amount: request.fromAmount
-      });
-      const feeComponent = [];
-      quoteResponse.quote.includedFees.forEach(fee => {
-        switch (fee.type) {
-          case ChainflipFeeType.INGRESS:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.EGRESS:
-            {
-              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
-              feeComponent.push({
-                tokenSlug,
-                amount: fee.amount,
-                feeType: _swap2.SwapFeeType.NETWORK_FEE
-              });
-              break;
-            }
-          case ChainflipFeeType.NETWORK:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.LIQUIDITY:
-            {
-              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
-              feeComponent.push({
-                tokenSlug,
-                amount: fee.amount,
-                feeType: _swap2.SwapFeeType.PLATFORM_FEE
-              });
-              break;
-            }
-        }
-      });
-      const defaultFeeToken = (0, _utils._isNativeToken)(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: quoteResponse.quote.egressAmount.toString(),
-        rate: (0, _utils2.calculateSwapRate)(request.fromAmount, quoteResponse.quote.egressAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
-        minSwap: metadata.minSwap.value,
-        maxSwap: (_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value,
-        estimatedArrivalTime: quoteResponse.quote.estimatedDurationSeconds,
-        // in seconds
-        isLowLiquidity: quoteResponse.quote.lowLiquidityWarning,
-        feeInfo: {
-          feeComponent: feeComponent,
-          defaultFeeToken,
-          feeOptions: [defaultFeeToken]
-        },
-        route: {
-          path: this.parseSwapPath(fromAsset, toAsset)
-        }
-      };
-    } catch (e) {
-      var _error$response;
-      const error = e;
-      const errorObj = error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data;
-      if (errorObj && errorObj.error && errorObj.error.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        // todo: Chainflip will improve this
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
-  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 _swap2.SwapStepType.DEFAULT:
-            return Promise.resolve([]);
-          case _swap2.SwapStepType.TOKEN_APPROVAL:
-            return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === _swap2.SwapStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
-  async handleSubmitStep(params) {
-    const {
-      address,
-      quote,
-      recipient
-    } = params;
-    const pair = quote.pair;
-    const fromAsset = this.chainService.getAssetBySlug(pair.from);
-    const toAsset = this.chainService.getAssetBySlug(pair.to);
-    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const chainType = (0, _utils._isSubstrateChain)(chainInfo) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
-    const receiver = recipient !== null && recipient !== void 0 ? recipient : address;
-    const srcChainId = this.chainMapping[fromAsset.originChain];
-    const destChainId = this.chainMapping[toAsset.originChain];
-    const fromAssetId = this.assetMapping[fromAsset.slug];
-    const toAssetId = this.assetMapping[toAsset.slug];
-    const depositAddressResponse = await this.swapSdk.requestDepositAddress({
-      srcChain: srcChainId,
-      destChain: destChainId,
-      srcAsset: fromAssetId,
-      destAsset: toAssetId,
-      destAddress: receiver,
-      amount: quote.fromAmount
-    });
-    const txData = {
-      address,
-      provider: this.providerInfo,
-      quote: params.quote,
-      slippage: params.slippage,
-      recipient,
-      depositChannelId: depositAddressResponse.depositChannelId,
-      depositAddress: depositAddressResponse.depositAddress,
-      process: params.process
-    };
-    let extrinsic;
-    if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
-      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
-      const substrateApi = await chainApi.isReady;
-      const [submittableExtrinsic] = await (0, _transfer.createTransferExtrinsic)({
-        from: address,
-        networkKey: chainInfo.slug,
-        substrateApi,
-        to: depositAddressResponse.depositAddress,
-        tokenInfo: fromAsset,
-        transferAll: false,
-        // always false, because we do not allow swapping all the balance
-        value: quote.fromAmount
-      });
-      extrinsic = submittableExtrinsic;
-    } else {
-      if ((0, _utils._isNativeToken)(fromAsset)) {
-        const [transactionConfig] = await (0, _transfer2.getEVMTransactionObject)(chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
-        extrinsic = transactionConfig;
-      } else {
-        const [transactionConfig] = await (0, _transfer2.getERC20TransactionObject)((0, _utils._getContractAddressOfToken)(fromAsset), chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
-        extrinsic = transactionConfig;
-      }
-    }
-    return {
-      txChain: fromAsset.originChain,
-      txData,
-      extrinsic,
-      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? quote.fromAmount : '0',
-      // todo
-      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
-      chainType
-    };
-  }
-  async handleSwapProcess(params) {
-    const {
-      currentStep,
-      process
-    } = params;
-    const type = process.steps[currentStep].type;
-    switch (type) {
-      case _swap2.SwapStepType.DEFAULT:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap2.SwapStepType.SWAP:
-        return this.handleSubmitStep(params);
-      default:
-        return this.handleSubmitStep(params);
-    }
-  }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _swap2.SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep]);
-  }
-}
-exports.ChainflipSwapHandler = ChainflipSwapHandler;