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

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

@@ -25,8 +25,36 @@ const API_URL = 'https://trade-api.gateway.uniswap.org/v1';
 const headers = {
   'x-api-key': process.env.UNISWAP_API_KEY || ''
 };
-async function fetchCheckApproval(walletAddress, fromAmount, quote) {
-  const chainId = quote.chainId;
+async function fetchCheckApproval(request) {
+  const {
+    address,
+    amount,
+    classicQuote,
+    dutchQuote
+  } = request;
+  let chainId;
+  let tokenIn;
+  let tokenOut;
+  if (classicQuote) {
+    chainId = classicQuote.chainId;
+    tokenIn = classicQuote.input.token;
+    tokenOut = classicQuote.output.token;
+  } else if (dutchQuote) {
+    /**
+     *  In Dutch order swap, the outputs field is an array instead of a single output since it might contain filler's output to pay fee.
+     *  Need to filter exactly output that come to recipient address.
+     */
+    const output = dutchQuote.orderInfo.outputs.find(output => output.recipient.toLowerCase() === address.toLowerCase());
+    if (!output) {
+      return undefined; // todo: recheck
+    }
+
+    chainId = dutchQuote.orderInfo.chainId;
+    tokenIn = dutchQuote.orderInfo.input.token;
+    tokenOut = output.token;
+  } else {
+    return undefined;
+  }
   const response = await fetch(`${API_URL}/check_approval`, {
     method: 'POST',
     headers: {
@@ -34,16 +62,16 @@ async function fetchCheckApproval(walletAddress, fromAmount, quote) {
       'Content-Type': 'application/json'
     },
     body: JSON.stringify({
-      walletAddress,
-      amount: (0, _bignumber.default)(fromAmount).multipliedBy(2).toString(),
-      token: quote.input.token,
+      walletAddress: address,
+      amount: (0, _bignumber.default)(amount).multipliedBy(2).toFixed(0),
+      token: tokenIn,
       chainId: chainId,
-      tokenOut: quote.output.token,
-      tokenOutChainId: chainId
+      tokenOut: tokenOut,
+      tokenOutChainId: chainId // swap in-chain
     })
   });
-  const data = await response.json();
-  return data;
+
+  return await response.json();
 }
 class UniswapHandler {
   constructor(chainService, balanceService, transactionService, feeService) {
@@ -103,11 +131,38 @@ class UniswapHandler {
     if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    const quoteMetadata = selectedQuote.metadata.quote;
-    const sender = quoteMetadata.swapper;
-    const sendingValue = quoteMetadata.input.amount;
+    const quoteMetadata = selectedQuote.metadata;
+    let sender;
+    let sendingValue;
+    let checkApprovalResponse;
+    if (quoteMetadata.routing === 'CLASSIC') {
+      const quote = quoteMetadata.quote;
+      sender = quote.swapper;
+      sendingValue = quote.input.amount;
+      checkApprovalResponse = await fetchCheckApproval({
+        address: sender,
+        amount: sendingValue,
+        classicQuote: quote
+      });
+    } else if (quoteMetadata.routing === 'DUTCH_LIMIT' || quoteMetadata.routing === 'DUTCH_V2') {
+      const quote = quoteMetadata.quote;
+      sender = quote.orderInfo.swapper;
+      sendingValue = quote.orderInfo.input.startAmount;
+      checkApprovalResponse = await fetchCheckApproval({
+        address: sender,
+        amount: sendingValue,
+        dutchQuote: quote
+      });
+    } else {
+      return undefined;
+    }
+    if (!checkApprovalResponse) {
+      return undefined;
+    }
     const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
-    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quoteMetadata);
+    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(fromTokenInfo));
+    const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
+    const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
     const approval = checkApprovalResponse.approval;
     if (!approval) {
       return Promise.resolve(undefined);
@@ -119,27 +174,41 @@ class UniswapHandler {
     } catch (e) {
       // Empty
     }
+    const tx = await (0, _web.getERC20SpendingApprovalTx)(spender, sender, tokenContract, evmApi);
+    const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+    const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
+    const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+    const feeInfo = {
+      feeComponent: [{
+        feeType: _types.SwapFeeType.NETWORK_FEE,
+        amount: estimatedFee,
+        tokenSlug: nativeTokenSlug
+      }],
+      defaultFeeToken: nativeTokenSlug,
+      feeOptions: [nativeTokenSlug]
+    };
     const submitStep = {
       name: 'Approve token for swap',
       type: _types.CommonStepType.TOKEN_APPROVAL,
       // @ts-ignore
       metadata: {
         tokenApprove: fromTokenInfo.slug,
-        contractAddress: (0, _utils2._getContractAddressOfToken)(fromTokenInfo),
+        contractAddress: (0, _utils2._getContractAddressOfToken)(fromTokenInfo) || approval.to,
         spenderAddress: spender,
         owner: sender,
+        // todo: use approval.from?
         amount: sendingValue,
         isUniswapApprove: true
       }
     };
-    return Promise.resolve([submitStep, selectedQuote.feeInfo]); // todo: wrong feeInfo, please check
+    return Promise.resolve([submitStep, feeInfo]);
   }
-
   async getApproveBridge(params) {
     const quote = params.selectedQuote;
     if (!quote) {
       return Promise.resolve(undefined);
     }
+    console.log('params', params);
     const sendingAmount = quote.toAmount;
     const senderAddress = params.request.address;
     const fromTokenInfo = this.chainService.getAssetBySlug(quote.pair.to);
@@ -147,13 +216,25 @@ class UniswapHandler {
     const fromChainId = (0, _utils2._getEvmChainId)(fromChainInfo);
     const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
     const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
+    const toTokenInfo = this.chainService.getAssetBySlug(params.request.pair.to);
+    const toChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(toTokenInfo));
     if ((0, _utils2._isNativeToken)(fromTokenInfo)) {
       return Promise.resolve(undefined);
     }
     if (!fromChainId) {
       throw Error('Error getting Evm chain Id');
     }
-    const spokePoolAddress = _acrossBridge.SpokePoolMapping[fromChainId].SpokePool.address;
+    const inputData = {
+      destinationTokenInfo: toTokenInfo,
+      originTokenInfo: fromTokenInfo,
+      sendingValue: sendingAmount,
+      sender: senderAddress,
+      recipient: senderAddress,
+      destinationChain: toChainInfo,
+      originChain: fromChainInfo
+    };
+    const acrossQuote = await (0, _acrossBridge.getAcrossQuote)(inputData);
+    const spokePoolAddress = acrossQuote.to;
     const allowance = await (0, _web.getERC20Allowance)(spokePoolAddress, senderAddress, tokenContract, evmApi);
     if (allowance && (0, _bignumber.default)(allowance).gt(sendingAmount)) {
       return Promise.resolve(undefined);
@@ -362,14 +443,38 @@ class UniswapHandler {
     if (!sender || !sendingValue) {
       throw new Error('Sender or value is not found');
     }
-
-    // todo: move quote param to metadata;
-
-    const {
-      quote
-    } = params.quote.metadata;
-    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quote);
+    const quoteMetadata = params.quote.metadata;
+    let spenderAddress;
+    let contractAddress;
+    let chainId;
+    let checkApprovalResponse;
+    if (quoteMetadata.routing === 'CLASSIC') {
+      const quote = quoteMetadata.quote;
+      spenderAddress = quote.output.token;
+      contractAddress = quote.input.token;
+      chainId = quote.chainId.toString();
+      checkApprovalResponse = await fetchCheckApproval({
+        address: sender,
+        amount: sendingValue,
+        classicQuote: quote
+      });
+    } else if (quoteMetadata.routing === 'DUTCH_LIMIT' || quoteMetadata.routing === 'DUTCH_V2') {
+      const quote = quoteMetadata.quote;
+      spenderAddress = quote.orderInfo.outputs[0].token;
+      contractAddress = quote.orderInfo.input.token;
+      chainId = quote.orderInfo.chainId.toString();
+      checkApprovalResponse = await fetchCheckApproval({
+        address: sender,
+        amount: sendingValue,
+        dutchQuote: quote
+      });
+    } else {
+      throw Error('Unsupported quote route');
+    }
     let transactionConfig = {};
+    if (!checkApprovalResponse) {
+      throw new Error('Check approval fail');
+    }
     const approval = checkApprovalResponse.approval;
     if (approval) {
       var _priority$options, _priority$options$Fee, _priority$options2;
@@ -389,11 +494,11 @@ class UniswapHandler {
     }
     const chain = fromAsset.originChain;
     const _data = {
-      spenderAddress: quote.output.token,
-      contractAddress: quote.input.token,
+      spenderAddress,
+      contractAddress,
       amount: params.quote.fromAmount,
       owner: params.address,
-      chain: quote.chainId.toString()
+      chain: chainId
     };
     return Promise.resolve({
       txChain: chain,
@@ -465,19 +570,93 @@ class UniswapHandler {
       const transactionResponse = await postTransactionResponse.json();
       extrinsic = transactionResponse.swap;
     } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
-      // todo: update condition and add handle exception
-      // UniswapX, UniswapX_V2, and UniswapX_V3 are alternately referred to as DutchQuote, DutchQuoteV2, and DutchQuoteV3
-      postTransactionResponse = await fetch(`${API_URL}/order`, {
-        method: 'POST',
-        headers: {
-          ...headers,
-          'Content-Type': 'application/json'
+      const dutchQuote = quote;
+      const submitSwapOrder = async () => {
+        try {
+          const res = await fetch(`${API_URL}/order`, {
+            method: 'POST',
+            headers: {
+              ...headers,
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              signature: signature,
+              quote: dutchQuote
+            })
+          });
+          return res.ok;
+        } catch (e) {
+          console.log(e);
+          return false;
+        }
+      };
+      const retryGetUniswapTx = async (fn, options) => {
+        let lastError;
+        for (let i = 0; i < options.retries; i++) {
+          try {
+            const orderInfo = await fn();
+            if (orderInfo && orderInfo.orderStatus === 'filled') {
+              return orderInfo;
+            }
+            await new Promise(resolve => setTimeout(resolve, options.delay));
+          } catch (e) {
+            if (e instanceof Error) {
+              lastError = e;
+            }
+            await new Promise(resolve => setTimeout(resolve, options.delay));
+          }
+        }
+        console.error('UniswapX order timeout', lastError); // throw only last error, in case no successful result from fn()
+
+        return undefined;
+      };
+      const cronCheckTxSuccess = async () => {
+        const delay = 10000;
+        const retries = 50;
+        const orderId = dutchQuote.orderId;
+        const swapper = dutchQuote.orderInfo.swapper;
+        return retryGetUniswapTx(async () => {
+          try {
+            const response = await fetch(`${API_URL}/orders?orderId=${orderId}&swapper=${swapper}`, {
+              method: 'GET',
+              headers: {
+                ...headers,
+                'Content-Type': 'application/json'
+              }
+            });
+            if (response.ok) {
+              const res = await response.json();
+              return res.orders.find(e => e.orderId === orderId && e.swapper === swapper.toLowerCase());
+            }
+            return undefined;
+          } catch (e) {
+            return undefined;
+          }
+        }, {
+          retries,
+          delay
+        });
+      };
+      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: {
+          submitSwapOrder,
+          cronCheckTxSuccess
         },
-        body: JSON.stringify({
-          signature: signature,
-          quote: quote
-        })
-      });
+        transferNativeAmount: (0, _utils2._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+        extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+        chainType: _KoniTypes.ChainType.EVM,
+        isDutch: true
+      };
     }
     const txData = {
       address: params.address,
@@ -499,9 +678,12 @@ class UniswapHandler {
   handlePermitStep(params) {
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
     const {
-      permitData
+      permitData,
+      routing
     } = params.quote.metadata;
     const processId = params.cacheProcessId;
+    const primaryType = routing === 'CLASSIC' ? 'PermitSingle' : routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2' ? 'PermitWitnessTransferFrom' : ''; // todo
+
     let validatePayload;
     if (permitData) {
       const payload = {
@@ -519,7 +701,7 @@ class UniswapHandler {
           ...permitData.types
         },
         domain: permitData.domain,
-        primaryType: 'PermitSingle',
+        primaryType,
         message: permitData.values
       };
       validatePayload = (0, _logicValidation.validateTypedSignMessageDataV3V4)({

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

@@ -25,6 +25,7 @@ var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
+var _kyberHandler = require("./handler/kyber-handler");
 var _simpleswapHandler = require("./handler/simpleswap-handler");
 var _uniswapHandler = require("./handler/uniswap-handler");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -41,12 +42,21 @@ class SwapService {
     this.eventService = state.eventService;
     this.chainService = state.chainService;
   }
-  async askProvidersForQuote(request) {
+  async askProvidersForQuote(_request) {
     var _subwalletApiSdk$swap;
     const availableQuotes = [];
+
+    // hotfix
+    const request = {
+      ..._request,
+      isSupportKyberVersion: true
+    };
     const quotes = await ((_subwalletApiSdk$swap = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData(request));
     if (Array.isArray(quotes)) {
       quotes.forEach(quoteData => {
+        if (!_swap._SUPPORTED_SWAP_PROVIDERS.includes(quoteData.provider)) {
+          return;
+        }
         if (!quoteData.quote || Object.keys(quoteData.quote).length === 0) {
           return;
         }
@@ -120,6 +130,12 @@ class SwapService {
     console.group('Swap Logger');
     console.log('path', path);
     console.log('swapQuoteResponse', swapQuoteResponse);
+    if (swapQuoteResponse.optimalQuote && swapQuoteResponse.optimalQuote.metadata) {
+      const routing = swapQuoteResponse.optimalQuote.metadata.routing;
+      if (routing) {
+        console.log('Uniswap routing', routing);
+      }
+    }
     let optimalProcess;
     try {
       optimalProcess = await this.generateOptimalProcessV2({
@@ -130,6 +146,12 @@ class SwapService {
     } catch (e) {
       throw new Error(e.message);
     }
+    if (swapQuoteResponse.error) {
+      return {
+        process: optimalProcess,
+        quote: swapQuoteResponse
+      };
+    }
     console.log('optimalProcess', optimalProcess);
     console.groupEnd();
     if (JSON.stringify((0, _utils2.processStepsToPathActions)(optimalProcess.steps)) !== JSON.stringify(optimalProcess.path.map(e => e.action))) {
@@ -253,7 +275,14 @@ class SwapService {
     var _subwalletApiSdk$swap2;
     const availablePath = await ((_subwalletApiSdk$swap2 = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap2 === void 0 ? void 0 : _subwalletApiSdk$swap2.findAvailablePath(request));
     if (!availablePath) {
-      throw Error('No available path');
+      return {
+        path: [],
+        swapQuoteResponse: {
+          quotes: [],
+          aliveUntil: Date.now() + _utils2.SWAP_QUOTE_TIMEOUT_MAP.error,
+          error: new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE)
+        }
+      };
     }
     const {
       path
@@ -361,6 +390,9 @@ class SwapService {
         case _swap.SwapProviderId.UNISWAP:
           this.handlers[providerId] = new _uniswapHandler.UniswapHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
           break;
+        case _swap.SwapProviderId.KYBER:
+          this.handlers[providerId] = new _kyberHandler.KyberHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/cjs/services/swap-service/utils.js

@@ -54,8 +54,11 @@ const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
   default: 90000,
   [_swap.SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
-  [_swap.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+  [_swap.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000,
+  error: 10000
 };
+
+// deprecated
 exports.SWAP_QUOTE_TIMEOUT_MAP = SWAP_QUOTE_TIMEOUT_MAP;
 const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [_swap.SwapProviderId.HYDRADX_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX],