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

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

@@ -0,0 +1,399 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SwapSDK } from '@chainflip/sdk/swap';
+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 { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { createTransferExtrinsic } from '@subwallet/extension-base/koni/api/dotsama/transfer';
+import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/koni/api/tokens/evm/transfer';
+import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken, _isSubstrateChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { calculateSwapRate, CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING, getChainflipEarlyValidationError, 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';
+var ChainflipFeeType;
+(function (ChainflipFeeType) {
+  ChainflipFeeType["INGRESS"] = "INGRESS";
+  ChainflipFeeType["NETWORK"] = "NETWORK";
+  ChainflipFeeType["EGRESS"] = "EGRESS";
+  ChainflipFeeType["LIQUIDITY"] = "LIQUIDITY";
+})(ChainflipFeeType || (ChainflipFeeType = {}));
+const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
+const INTERMEDIARY_TESTNET_ASSET_SLUG = 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 = {}));
+export class ChainflipSwapHandler {
+  constructor(chainService, balanceService, isTestnet = true) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
+      providerSlug: isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET
+    });
+    this.isTestnet = isTestnet;
+    this.swapSdk = new 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 CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
+    } else {
+      return CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
+    }
+  }
+  get chainMapping() {
+    if (this.isTestnet) {
+      return CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
+    } else {
+      return 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: 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: SwapErrorType.UNKNOWN
+        };
+      }
+      const bnAmount = new BigNumber(request.fromAmount);
+      const bnMinSwap = new BigNumber(srcAssetData.minimumSwapAmount);
+      if (srcAssetData.maximumSwapAmount) {
+        const bnMaxProtocolSwap = new BigNumber(srcAssetData.maximumSwapAmount);
+        if (bnMinSwap.gte(bnMaxProtocolSwap)) {
+          return {
+            error: SwapErrorType.UNKNOWN
+          };
+        }
+        if (bnAmount.gte(bnMaxProtocolSwap)) {
+          return {
+            error: SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+            metadata: {
+              minSwap: {
+                value: srcAssetData.minimumSwapAmount,
+                decimals: _getAssetDecimals(fromAsset),
+                symbol: fromAsset.symbol
+              },
+              maxSwap: {
+                value: bnMaxProtocolSwap.toString(),
+                decimals: _getAssetDecimals(fromAsset),
+                symbol: fromAsset.symbol
+              },
+              chain: srcChainInfo
+            }
+          };
+        }
+      }
+      if (bnAmount.lt(bnMinSwap)) {
+        // might miss case when minSwap is 0
+        return {
+          error: SwapErrorType.NOT_MEET_MIN_SWAP,
+          metadata: {
+            minSwap: {
+              value: srcAssetData.minimumSwapAmount,
+              decimals: _getAssetDecimals(fromAsset),
+              symbol: fromAsset.symbol
+            },
+            maxSwap: {
+              value: srcAssetData.maximumSwapAmount,
+              decimals: _getAssetDecimals(fromAsset),
+              symbol: fromAsset.symbol
+            },
+            chain: srcChainInfo
+          }
+        };
+      }
+      return {
+        metadata: {
+          minSwap: {
+            value: srcAssetData.minimumSwapAmount,
+            decimals: _getAssetDecimals(fromAsset),
+            symbol: fromAsset.symbol
+          },
+          maxSwap: {
+            value: srcAssetData.maximumSwapAmount,
+            decimals: _getAssetDecimals(fromAsset),
+            symbol: fromAsset.symbol
+          },
+          chain: srcChainInfo
+        }
+      };
+    } catch (e) {
+      return {
+        error: 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 = _getChainNativeTokenSlug(fromChain);
+    if (!fromAsset || !toAsset) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+    const earlyValidation = await this.validateSwapRequest(request);
+    const metadata = earlyValidation.metadata;
+    if (earlyValidation.error) {
+      return 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: 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: SwapFeeType.PLATFORM_FEE
+              });
+              break;
+            }
+        }
+      });
+      const defaultFeeToken = _isNativeToken(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
+      return {
+        pair: request.pair,
+        fromAmount: request.fromAmount,
+        toAmount: quoteResponse.quote.egressAmount.toString(),
+        rate: calculateSwapRate(request.fromAmount, quoteResponse.quote.egressAmount.toString(), fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || 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(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+      }
+      if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
+        return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
+      }
+      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+  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.TOKEN_APPROVAL:
+            return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+          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 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 = _isSubstrateChain(chainInfo) ? ChainType.SUBSTRATE : 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 === ChainType.SUBSTRATE) {
+      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+      const substrateApi = await chainApi.isReady;
+      const [submittableExtrinsic] = await 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 (_isNativeToken(fromAsset)) {
+        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? quote.fromAmount : '0',
+      // todo
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+  async 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.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  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.getSubmitStep]);
+  }
+}

package/services/swap-service/handler/hydradx-handler.d.ts

@@ -0,0 +1,36 @@
+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 HydradxHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    private tradeRouter;
+    private readonly isTestnet;
+    isReady: boolean;
+    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    init(): Promise<void>;
+    chain: () => string;
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    getFeeOptionStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
+    private getSwapPathErrors;
+    private parseSwapPath;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSetFeeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
+    get referralCode(): "WALLET" | "ASSETHUB";
+    get referralAccount(): "7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a" | "7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ";
+}