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

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

@@ -39,6 +39,7 @@ export declare class PriceService implements StoppableServiceInterface, PersistD
         };
     };
     init(): Promise<void>;
+    checkCoinGeckoPriceSupport(priceId: string): boolean;
     loadData(): Promise<void>;
     persistData(): Promise<void>;
     startPromiseHandler: {

package/services/price-service/index.js

@@ -20,6 +20,7 @@ const DEFAULT_PRICE_SUBJECT = {
     isPrefix: true
   },
   priceMap: {},
+  priceCoinGeckoSupported: [],
   price24hMap: {},
   exchangeRateMap: {},
   lastUpdatedMap: {}
@@ -96,6 +97,7 @@ export class PriceService {
     let {
       lastUpdatedMap,
       price24hMap,
+      priceCoinGeckoSupported,
       priceMap
     } = this.rawPriceSubject.value;
     let exchangeRateData = this.rawExchangeRateMap.value;
@@ -125,6 +127,7 @@ export class PriceService {
       },
       currency: currencyKey,
       exchangeRateMap: exchangeRateData,
+      priceCoinGeckoSupported,
       currencyData: staticData[StaticKey.CURRENCY_SYMBOL][currencyKey || DEFAULT_CURRENCY],
       lastUpdatedMap: {
         ...lastUpdatedMap
@@ -260,6 +263,15 @@ export class PriceService {
     this.status = 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/services/request-service/handler/EvmRequestHandler.js

@@ -22,7 +22,8 @@ export default class EvmRequestHandler {
     evmSignatureRequest: {},
     evmSendTransactionRequest: {},
     evmWatchTransactionRequest: {},
-    errorConnectNetwork: {}
+    errorConnectNetwork: {},
+    submitApiRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {
@@ -214,6 +215,8 @@ export default 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/services/swap-service/handler/kyber-handler.d.ts

@@ -0,0 +1,28 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import FeeService from '../../fee-service/service';
+import TransactionService from '../../transaction-service';
+import { SwapBaseInterface } from './base-handler';
+export interface KyberSwapQuoteMetadata {
+    priceImpact?: string;
+}
+export declare const KYBER_CLIENT_ID: string;
+export declare class KyberHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    transactionService: TransactionService;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, transactionService: TransactionService, feeService: FeeService);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get feeService(): FeeService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    getApprovalStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    private tokenApproveSpending;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+}

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

@@ -0,0 +1,346 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { estimateTxFee, getERC20Allowance, getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain, combineEthFee } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import BigNumber from 'bignumber.js';
+import { _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
+import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
+import { SwapBaseHandler } from "./base-handler.js";
+export const KYBER_CLIENT_ID = process.env.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(BasicTxErrorType.INTERNAL_ERROR, routeData.message)
+        };
+      }
+      routeSummary = routeData.data.routeSummary;
+    } catch (error) {
+      console.error('Error:', error);
+      return {
+        error: new TransactionError(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(SwapErrorType.NOT_ENOUGH_LIQUIDITY)
+        };
+      }
+      if (lowerDetails.some(d => d.includes('execution reverted')) || msg.includes('smaller than estimated')) {
+        return {
+          error: new SwapError(SwapErrorType.NOT_MEET_MIN_EXPECTED)
+        };
+      }
+      return {
+        error: new TransactionError(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(BasicTxErrorType.INTERNAL_ERROR)
+    };
+  }
+}
+export class KyberHandler {
+  constructor(chainService, balanceService, transactionService, feeService) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: 'Kyber',
+      providerSlug: SwapProviderId.KYBER
+    });
+    this.transactionService = transactionService;
+    this.providerSlug = 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 (_isNativeToken(fromAsset)) {
+        return Promise.resolve(undefined);
+      }
+      const metadata = selectedQuote.metadata;
+      const routerContract = metadata.routerAddress;
+      const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+      const fromContractAddress = _getContractAddressOfToken(fromAsset);
+      const allowance = await getERC20Allowance(routerContract, params.request.address, fromContractAddress, evmApi);
+      if (allowance && new BigNumber(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 = _getContractAddressOfToken(fromTokenInfo);
+      const spenderAddress = metadata.routerAddress;
+      const submitStep = {
+        name: 'Approve token',
+        type: CommonStepType.TOKEN_APPROVAL,
+        metadata: {
+          tokenApprove: fromTokenInfo.slug,
+          contractAddress: tokenContract,
+          spenderAddress: spenderAddress,
+          amount: sendingAmount,
+          owner: senderAddress
+        }
+      };
+      const tx = await getERC20SpendingApprovalTx(spenderAddress, senderAddress, tokenContract, evmApi);
+      const evmFeeInfo = await this.feeService.subscribeChainFee(getId(), fromTokenInfo.originChain, 'evm');
+      const estimatedFee = await estimateTxFee(tx, evmApi, evmFeeInfo);
+      const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+      const nativeTokenSlug = _getChainNativeTokenSlug(fromChainInfo);
+      const feeInfo = {
+        feeComponent: [{
+          feeType: 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 === 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: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: request.fromAmount.toString(),
+        expectedReceive: selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(request.address, originChain),
+        receiver: _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 CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case CommonStepType.TOKEN_APPROVAL:
+        return this.tokenApproveSpending(params);
+      case 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 = _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(BasicTxErrorType.INVALID_PARAMS);
+    }
+    const routerContract = metadata.routerAddress;
+    const transactionConfig = await 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: ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: 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 = _reformatAddressWithChain(params.address, chainInfo);
+    const recipient = _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 calculateGasFeeParams(evmApi, evmApi.chainSlug);
+    const fee = 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: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType: 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 (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
+}

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

@@ -12,6 +12,53 @@ export declare type PermitData = {
     types: Record<string, unknown>;
     values: unknown;
 };
+export interface UniswapMetadata {
+    permitData: PermitData;
+    quote: UniswapQuote;
+    routing: string;
+}
+declare type UniswapQuote = UniswapClassicQuote | UniswapDutchQuote;
+interface UniswapClassicQuote {
+    swapper: string;
+    chainId: number;
+    input: {
+        amount: string;
+        token: string;
+    };
+    output: {
+        amount: string;
+        token: string;
+    };
+}
+interface UniswapDutchQuote {
+    orderInfo: {
+        swapper: string;
+        chainId: number;
+        input: UniswapDutchInput;
+        outputs: UniswapDutchOutput[];
+    };
+    orderId: string;
+}
+interface UniswapDutchInput {
+    startAmount: string;
+    endAmount: string;
+    token: string;
+}
+interface UniswapDutchOutput {
+    startAmount: string;
+    endAmount: string;
+    token: string;
+    recipient: string;
+}
+export interface UniswapOrders {
+    orders: UniswapOrderInfo[];
+}
+export interface UniswapOrderInfo {
+    orderStatus: 'open' | 'expired' | 'error' | 'cancelled' | 'filled' | 'unverified' | 'insufficient-funds';
+    orderId: string;
+    swapper: string;
+    txHash: string;
+}
 export declare class UniswapHandler implements SwapBaseInterface {
     private swapBaseHandler;
     transactionService: TransactionService;
@@ -44,3 +91,4 @@ export declare class UniswapHandler implements SwapBaseInterface {
     };
     validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }
+export {};