@subwallet/extension-base 1.3.34-0 → 1.3.36-0

package/cjs/services/price-service/coingecko.js

@@ -60,28 +60,33 @@ const fetchDerivativeTokenSlugs = async () => {
 };
 const getPriceMap = async function (priceIds) {
   let currency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'USD';
+  let skipDerivativePrice = arguments.length > 2 ? arguments[2] : undefined;
   const idStr = Array.from(priceIds).join(',');
   let response;
   try {
     var _response3, _response5;
     const derivativePriceMap = {};
+    const lastUpdatedMap = {};
     let derivativeApiError = false;
-    try {
-      const responseDerivativeTokens = await fetch(`${apiCacheDomain}/api/price/derivative-get`);
-      const generateDerivativePriceRaw = (await (responseDerivativeTokens === null || responseDerivativeTokens === void 0 ? void 0 : responseDerivativeTokens.json())) || [];
-      if (Array.isArray(generateDerivativePriceRaw)) {
-        generateDerivativePriceRaw.forEach(token => {
-          if (token.id) {
-            derivativePriceMap[token.id] = token.derived_price;
-          }
-        });
-      } else {
-        console.warn('Invalid data from derivative API:', generateDerivativePriceRaw);
+    if (!skipDerivativePrice) {
+      try {
+        const responseDerivativeTokens = await fetch(`${apiCacheDomain}/api/price/derivative-get`);
+        const generateDerivativePriceRaw = (await (responseDerivativeTokens === null || responseDerivativeTokens === void 0 ? void 0 : responseDerivativeTokens.json())) || [];
+        if (Array.isArray(generateDerivativePriceRaw)) {
+          generateDerivativePriceRaw.forEach(token => {
+            if (token.id) {
+              derivativePriceMap[token.id] = token.derived_price;
+              lastUpdatedMap[token.id] = new Date(token.cached_at || Date.now());
+            }
+          });
+        } else {
+          console.warn('Invalid data from derivative API:', generateDerivativePriceRaw);
+          derivativeApiError = true;
+        }
+      } catch (error) {
+        console.error('Error fetching derivative API:', error);
         derivativeApiError = true;
       }
-    } catch (error) {
-      console.error('Error fetching derivative API:', error);
-      derivativeApiError = true;
     }
     if (!useBackupApi) {
       try {
@@ -113,10 +118,11 @@ const getPriceMap = async function (priceIds) {
     const currencyData = _staticData.staticData[_staticData.StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
     const priceMap = {};
     const price24hMap = {};
-    const lastUpdatedMap = {};
+    const priceCoinGeckoSupported = [];
     responseDataPrice.forEach(val => {
       const currentPrice = val.current_price || 0;
       const price24h = currentPrice - (val.price_change_24h || 0);
+      priceCoinGeckoSupported.push(val.id);
       priceMap[val.id] = currentPrice;
       price24hMap[val.id] = price24h;
       lastUpdatedMap[val.id] = new Date(val.last_updated || val.last_updated_at || Date.now());
@@ -139,6 +145,7 @@ const getPriceMap = async function (priceIds) {
       currencyData,
       priceMap,
       price24hMap,
+      priceCoinGeckoSupported,
       lastUpdatedMap
     };
   } catch (e) {

package/cjs/services/price-service/index.js

@@ -26,6 +26,7 @@ const DEFAULT_PRICE_SUBJECT = {
     isPrefix: true
   },
   priceMap: {},
+  priceCoinGeckoSupported: [],
   price24hMap: {},
   exchangeRateMap: {},
   lastUpdatedMap: {}
@@ -103,6 +104,7 @@ class PriceService {
     let {
       lastUpdatedMap,
       price24hMap,
+      priceCoinGeckoSupported,
       priceMap
     } = this.rawPriceSubject.value;
     let exchangeRateData = this.rawExchangeRateMap.value;
@@ -132,6 +134,7 @@ class PriceService {
       },
       currency: currencyKey,
       exchangeRateMap: exchangeRateData,
+      priceCoinGeckoSupported,
       currencyData: _staticData.staticData[_staticData.StaticKey.CURRENCY_SYMBOL][currencyKey || DEFAULT_CURRENCY],
       lastUpdatedMap: {
         ...lastUpdatedMap
@@ -268,6 +271,15 @@ class PriceService {
     this.status = _types.ServiceStatus.INITIALIZED;
     this.eventService.on('asset.updateState', eventHandler);
   }
+  checkCoinGeckoPriceSupport(priceId) {
+    const {
+      priceCoinGeckoSupported
+    } = this.priceSubject.value;
+    if (!priceCoinGeckoSupported) {
+      return false;
+    }
+    return priceCoinGeckoSupported.includes(priceId);
+  }
   async loadData() {
     const data = await this.dbService.getPriceStore(this.priceSubject.value.currency);
     this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);

package/cjs/services/request-service/handler/EvmRequestHandler.js

@@ -29,7 +29,8 @@ class EvmRequestHandler {
     evmSignatureRequest: {},
     evmSendTransactionRequest: {},
     evmWatchTransactionRequest: {},
-    errorConnectNetwork: {}
+    errorConnectNetwork: {},
+    submitApiRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {
@@ -225,6 +226,8 @@ class EvmRequestHandler {
         result.payload = await this.signMessage(request);
       } else if (t === 'evmSendTransactionRequest') {
         result.payload = await this.signTransaction(request);
+      } else if (t === 'submitApiRequest') {
+        return;
       }
       if (t === 'evmSignatureRequest' || t === 'evmSendTransactionRequest') {
         const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;

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

@@ -0,0 +1,355 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KyberHandler = exports.KYBER_CLIENT_ID = void 0;
+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 _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils2 = require("../../chain-service/utils");
+var _utils3 = require("../../fee-service/utils");
+var _baseHandler = require("./base-handler");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const KYBER_CLIENT_ID = process.env.KYBER_CLIENT_ID || '';
+exports.KYBER_CLIENT_ID = KYBER_CLIENT_ID;
+const kyberUrl = 'https://aggregator-api.kyberswap.com';
+async function buildTxForSwap(params, chain) {
+  const {
+    recipient,
+    sender,
+    slippageTolerance
+  } = params;
+  let routeSummary = params.routeSummary;
+  if (!routeSummary || !routeSummary.tokenIn || !routeSummary.tokenOut || !routeSummary.amountIn) {
+    const queryParams = new URLSearchParams({
+      tokenIn: routeSummary.tokenIn,
+      tokenOut: routeSummary.tokenOut,
+      amountIn: routeSummary.amountIn,
+      gasInclude: 'true'
+    });
+    const url = `${kyberUrl}/${chain}/api/v1/routes?${queryParams.toString()}`;
+    try {
+      var _routeData$data;
+      const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-client-id': KYBER_CLIENT_ID,
+          accept: 'application/json'
+        }
+      });
+      const routeData = await res.json();
+      if (!routeData.success || !((_routeData$data = routeData.data) !== null && _routeData$data !== void 0 && _routeData$data.routeSummary)) {
+        return {
+          error: new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, routeData.message)
+        };
+      }
+      routeSummary = routeData.data.routeSummary;
+    } catch (error) {
+      console.error('Error:', error);
+      return {
+        error: new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)
+      };
+    }
+  }
+  const body = {
+    routeSummary,
+    sender,
+    recipient,
+    slippageTolerance,
+    ignoreCappedSlippage: true,
+    enableGasEstimation: true
+  };
+  try {
+    const res = await fetch(`${kyberUrl}/${chain}/api/v1/route/build`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-client-id': KYBER_CLIENT_ID,
+        accept: 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    const requestData = data.data;
+    if (!requestData || !requestData.routerAddress || !requestData.data || !requestData.gas) {
+      var _data$details$map, _data$details, _data$message$toLower, _data$message;
+      const lowerDetails = (_data$details$map = (_data$details = data.details) === null || _data$details === void 0 ? void 0 : _data$details.map(d => d.toLowerCase())) !== null && _data$details$map !== void 0 ? _data$details$map : [];
+      const msg = (_data$message$toLower = (_data$message = data.message) === null || _data$message === void 0 ? void 0 : _data$message.toLowerCase()) !== null && _data$message$toLower !== void 0 ? _data$message$toLower : '';
+      if (lowerDetails.some(d => d.includes('insufficient liquidity'))) {
+        return {
+          error: new _SwapError.SwapError(_types.SwapErrorType.NOT_ENOUGH_LIQUIDITY)
+        };
+      }
+      if (lowerDetails.some(d => d.includes('execution reverted')) || msg.includes('smaller than estimated')) {
+        return {
+          error: new _SwapError.SwapError(_types.SwapErrorType.NOT_MEET_MIN_EXPECTED)
+        };
+      }
+      return {
+        error: new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, data.message)
+      };
+    }
+    return {
+      data: {
+        from: sender,
+        to: requestData.routerAddress,
+        value: requestData.transactionValue,
+        data: requestData.data,
+        gas: requestData.gas
+      }
+    };
+  } catch (error) {
+    console.error('Kyber error:', error);
+    return {
+      error: new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)
+    };
+  }
+}
+class KyberHandler {
+  constructor(chainService, balanceService, transactionService, feeService) {
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: 'Kyber',
+      providerSlug: _types.SwapProviderId.KYBER
+    });
+    this.transactionService = transactionService;
+    this.providerSlug = _types.SwapProviderId.KYBER;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get feeService() {
+    return this.swapBaseHandler.feeService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
+  async getApprovalStep(params) {
+    const selectedQuote = params.selectedQuote;
+    if (selectedQuote) {
+      const fromAsset = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+      if ((0, _utils2._isNativeToken)(fromAsset)) {
+        return Promise.resolve(undefined);
+      }
+      const metadata = selectedQuote.metadata;
+      const routerContract = metadata.routerAddress;
+      const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+      const fromContractAddress = (0, _utils2._getContractAddressOfToken)(fromAsset);
+      const allowance = await (0, _web.getERC20Allowance)(routerContract, params.request.address, fromContractAddress, evmApi);
+      if (allowance && new _bignumber.default(allowance).gt(params.request.fromAmount)) {
+        return Promise.resolve(undefined);
+      }
+      const sendingAmount = selectedQuote.toAmount;
+      const senderAddress = params.request.address;
+      const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+      const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
+      const spenderAddress = metadata.routerAddress;
+      const submitStep = {
+        name: 'Approve token',
+        type: _types.CommonStepType.TOKEN_APPROVAL,
+        metadata: {
+          tokenApprove: fromTokenInfo.slug,
+          contractAddress: tokenContract,
+          spenderAddress: spenderAddress,
+          amount: sendingAmount,
+          owner: senderAddress
+        }
+      };
+      const tx = await (0, _web.getERC20SpendingApprovalTx)(spenderAddress, senderAddress, tokenContract, evmApi);
+      const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+      const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
+      const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+      const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+      const feeInfo = {
+        feeComponent: [{
+          feeType: _types.SwapFeeType.NETWORK_FEE,
+          amount: estimatedFee,
+          tokenSlug: nativeTokenSlug
+        }],
+        defaultFeeToken: nativeTokenSlug,
+        feeOptions: [nativeTokenSlug]
+      };
+      return Promise.resolve([submitStep, feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async getSubmitStep(params, stepIndex) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const stepData = path.find(action => action.action === _types.DynamicSwapType.SWAP);
+    if (!stepData || !stepData.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: request.fromAmount.toString(),
+        expectedReceive: selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: (0, _utils._reformatAddressWithChain)(request.address, originChain),
+        receiver: (0, _utils._reformatAddressWithChain)(request.recipient || request.address, destinationChain),
+        version: 2
+      }
+    };
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.CommonStepType.TOKEN_APPROVAL:
+        return this.tokenApproveSpending(params);
+      case _types.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async tokenApproveSpending(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const fromContract = (0, _utils2._getContractAddressOfToken)(fromAsset);
+    const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+    const chain = fromAsset.originChain;
+    const metadata = params.quote.metadata;
+    if (!metadata || !metadata.routerAddress) {
+      throw new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS);
+    }
+    const routerContract = metadata.routerAddress;
+    const transactionConfig = await (0, _web.getERC20SpendingApprovalTx)(routerContract, params.address, fromContract, evmApi);
+    const _data = {
+      spenderAddress: routerContract,
+      contractAddress: fromContract,
+      amount: params.quote.fromAmount,
+      owner: params.address,
+      chain: chain
+    };
+    return Promise.resolve({
+      txChain: chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM
+    });
+  }
+  async handleSubmitStep(params) {
+    var _params$recipient;
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const toAsset = this.chainService.getAssetBySlug(params.quote.pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const sender = (0, _utils._reformatAddressWithChain)(params.address, chainInfo);
+    const recipient = (0, _utils._reformatAddressWithChain)((_params$recipient = params.recipient) !== null && _params$recipient !== void 0 ? _params$recipient : sender, toChainInfo);
+    const metadata = params.quote.metadata;
+    const slippageTolerance = params.slippage * 10000;
+    const rawTx = await buildTxForSwap({
+      routeSummary: metadata.routeSummary,
+      sender: params.address,
+      recipient,
+      slippageTolerance
+    }, metadata.network);
+    if (rawTx.error) {
+      console.error('Kyber error:', rawTx.error);
+      throw rawTx.error;
+    }
+    const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+    const priority = await (0, _utils3.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+    const fee = (0, _utils.combineEthFee)(priority);
+    const transactionConfig = {
+      ...rawTx.data,
+      ...fee
+    };
+    const txData = {
+      address: params.address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: params.recipient,
+      process: params.process
+    };
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic: transactionConfig,
+      transferNativeAmount: (0, _utils2._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.EVM
+    };
+  }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
+}
+exports.KyberHandler = KyberHandler;