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

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

@@ -6,7 +6,7 @@ import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/K
 import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core/logic-validation';
 import { estimateTxFee, getERC20Allowance, getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
 import { createAcrossBridgeExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { SpokePoolMapping } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { getAcrossQuote } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -18,8 +18,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: {
@@ -27,16 +55,16 @@ async function fetchCheckApproval(walletAddress, fromAmount, quote) {
       'Content-Type': 'application/json'
     },
     body: JSON.stringify({
-      walletAddress,
-      amount: BigNumber(fromAmount).multipliedBy(2).toString(),
-      token: quote.input.token,
+      walletAddress: address,
+      amount: BigNumber(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();
 }
 export class UniswapHandler {
   constructor(chainService, balanceService, transactionService, feeService) {
@@ -96,11 +124,38 @@ export 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(_getAssetOriginChain(fromTokenInfo));
+    const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
+    const tokenContract = _getContractAddressOfToken(fromTokenInfo);
     const approval = checkApprovalResponse.approval;
     if (!approval) {
       return Promise.resolve(undefined);
@@ -112,27 +167,41 @@ export class UniswapHandler {
     } catch (e) {
       // Empty
     }
+    const tx = await getERC20SpendingApprovalTx(spender, sender, tokenContract, evmApi);
+    const evmFeeInfo = await this.feeService.subscribeChainFee(getId(), fromTokenInfo.originChain, 'evm');
+    const estimatedFee = await estimateTxFee(tx, evmApi, evmFeeInfo);
+    const nativeTokenSlug = _getChainNativeTokenSlug(fromChainInfo);
+    const feeInfo = {
+      feeComponent: [{
+        feeType: SwapFeeType.NETWORK_FEE,
+        amount: estimatedFee,
+        tokenSlug: nativeTokenSlug
+      }],
+      defaultFeeToken: nativeTokenSlug,
+      feeOptions: [nativeTokenSlug]
+    };
     const submitStep = {
       name: 'Approve token for swap',
       type: CommonStepType.TOKEN_APPROVAL,
       // @ts-ignore
       metadata: {
         tokenApprove: fromTokenInfo.slug,
-        contractAddress: _getContractAddressOfToken(fromTokenInfo),
+        contractAddress: _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);
@@ -140,13 +209,25 @@ export class UniswapHandler {
     const fromChainId = _getEvmChainId(fromChainInfo);
     const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
     const tokenContract = _getContractAddressOfToken(fromTokenInfo);
+    const toTokenInfo = this.chainService.getAssetBySlug(params.request.pair.to);
+    const toChainInfo = this.chainService.getChainInfoByKey(_getAssetOriginChain(toTokenInfo));
     if (_isNativeToken(fromTokenInfo)) {
       return Promise.resolve(undefined);
     }
     if (!fromChainId) {
       throw Error('Error getting Evm chain Id');
     }
-    const spokePoolAddress = SpokePoolMapping[fromChainId].SpokePool.address;
+    const inputData = {
+      destinationTokenInfo: toTokenInfo,
+      originTokenInfo: fromTokenInfo,
+      sendingValue: sendingAmount,
+      sender: senderAddress,
+      recipient: senderAddress,
+      destinationChain: toChainInfo,
+      originChain: fromChainInfo
+    };
+    const acrossQuote = await getAcrossQuote(inputData);
+    const spokePoolAddress = acrossQuote.to;
     const allowance = await getERC20Allowance(spokePoolAddress, senderAddress, tokenContract, evmApi);
     if (allowance && BigNumber(allowance).gt(sendingAmount)) {
       return Promise.resolve(undefined);
@@ -355,14 +436,38 @@ export 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;
@@ -382,11 +487,11 @@ export 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,
@@ -458,19 +563,93 @@ export 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: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
+        extrinsicType: ExtrinsicType.SWAP,
+        chainType: ChainType.EVM,
+        isDutch: true
+      };
     }
     const txData = {
       address: params.address,
@@ -492,9 +671,12 @@ export 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 = {
@@ -512,7 +694,7 @@ export class UniswapHandler {
           ...permitData.types
         },
         domain: permitData.domain,
-        primaryType: 'PermitSingle',
+        primaryType,
         message: permitData.values
       };
       validatePayload = validateTypedSignMessageDataV3V4({

package/services/swap-service/index.js

@@ -21,6 +21,7 @@ import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
+import { KyberHandler } from "./handler/kyber-handler.js";
 import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
 import { UniswapHandler } from "./handler/uniswap-handler.js";
 export class SwapService {
@@ -34,12 +35,21 @@ export 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.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData(request));
     if (Array.isArray(quotes)) {
       quotes.forEach(quoteData => {
+        if (!_SUPPORTED_SWAP_PROVIDERS.includes(quoteData.provider)) {
+          return;
+        }
         if (!quoteData.quote || Object.keys(quoteData.quote).length === 0) {
           return;
         }
@@ -113,6 +123,12 @@ export 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({
@@ -123,6 +139,12 @@ export 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(processStepsToPathActions(optimalProcess.steps)) !== JSON.stringify(optimalProcess.path.map(e => e.action))) {
@@ -246,7 +268,14 @@ export class SwapService {
     var _subwalletApiSdk$swap2;
     const availablePath = await ((_subwalletApiSdk$swap2 = subwalletApiSdk.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() + SWAP_QUOTE_TIMEOUT_MAP.error,
+          error: new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE)
+        }
+      };
     }
     const {
       path
@@ -354,6 +383,9 @@ export class SwapService {
         case SwapProviderId.UNISWAP:
           this.handlers[providerId] = new UniswapHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
           break;
+        case SwapProviderId.KYBER:
+          this.handlers[providerId] = new KyberHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/services/swap-service/utils.js

@@ -22,8 +22,11 @@ export const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
   default: 90000,
   [SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
-  [SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+  [SwapProviderId.CHAIN_FLIP_MAINNET]: 30000,
+  error: 10000
 };
+
+// deprecated
 export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [SwapProviderId.HYDRADX_MAINNET]: [COMMON_CHAIN_SLUGS.HYDRADX],
   [SwapProviderId.CHAIN_FLIP_MAINNET]: [COMMON_CHAIN_SLUGS.POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.ARBITRUM],

package/services/transaction-service/helpers/index.d.ts

@@ -1,11 +1,11 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { CardanoTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/cardano-transfer';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean, isWalletConnect?: boolean) => string;
 export declare const getValidationId: (chainType: string, chain: string) => string;
-export declare const isSubstrateTransaction: (tx: SWTransaction['transaction']) => tx is SubmittableExtrinsic;
-export declare const isTonTransaction: (tx: SWTransaction['transaction']) => tx is TonTransactionConfig;
-export declare const isCardanoTransaction: (tx: SWTransaction['transaction']) => tx is CardanoTransactionConfig;
-export declare const getBaseTransactionInfo: (transaction: SWTransaction, chainInfoMap: Record<string, _ChainInfo>) => string;
+export declare const isSubstrateTransaction: (tx: SWTransactionBase['transaction']) => tx is SubmittableExtrinsic;
+export declare const isTonTransaction: (tx: SWTransactionBase['transaction']) => tx is TonTransactionConfig;
+export declare const isCardanoTransaction: (tx: SWTransactionBase['transaction']) => tx is CardanoTransactionConfig;
+export declare const getBaseTransactionInfo: (transaction: SWTransactionBase, chainInfoMap: Record<string, _ChainInfo>) => string;

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

@@ -1,6 +1,6 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { SWPermitTransactionInput, SWTransaction, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWDutchTransactionInput, SWPermitTransactionInput, SWTransactionBase, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
 import { BaseStepType, BriefProcessStep, ProcessStep, ProcessTransactionData } from '@subwallet/extension-base/types';
 import { BehaviorSubject } from 'rxjs';
 import { TransactionConfig } from 'web3-core';
@@ -20,27 +20,31 @@ export default class TransactionService {
     constructor(state: KoniState);
     private get allTransactions();
     private get processingTransactions();
-    getTransaction(id: string): SWTransaction;
+    getTransaction(id: string): SWTransactionBase;
     private checkDuplicate;
     validateTransaction(transactionInput: SWTransactionInput): Promise<SWTransactionResponse>;
-    getTransactionSubject(): BehaviorSubject<Record<string, SWTransaction>>;
+    getTransactionSubject(): BehaviorSubject<Record<string, SWTransactionBase>>;
     get observables(): {
-        readonly transaction: import("rxjs").Observable<Record<string, SWTransaction>>;
+        readonly transaction: import("rxjs").Observable<Record<string, SWTransactionBase>>;
         readonly aliveProcess: import("rxjs").Observable<Record<string, ProcessTransactionData>>;
     };
     get values(): {
-        readonly transaction: Record<string, SWTransaction>;
+        readonly transaction: Record<string, SWTransactionBase>;
         readonly aliveProcess: Record<string, ProcessTransactionData>;
     };
     getCacheInfo(processId: string, step: BaseStepType): string;
     private updateAliveProcess;
     private fillTransactionDefaultInfo;
+    private fillDutchTransactionDefaultInfo;
     addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;
+    addDutchTransaction(inputTransaction: SWDutchTransactionInput): TransactionEmitter;
     generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
     handleTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
     handlePermitTransaction(transaction: SWPermitTransactionInput): Promise<SWTransactionResponse>;
+    handleDutchTransaction(transaction: SWDutchTransactionInput): Promise<SWTransactionResponse>;
     private sendTransaction;
     private sendPermitTransaction;
+    private sendDutchTransaction;
     private removeTransaction;
     private updateTransaction;
     private getTransactionLink;
@@ -55,6 +59,7 @@ export default class TransactionService {
     generateHashPayload(chain: string, transaction: TransactionConfig): HexString;
     private signAndSendEvmTransaction;
     private signAndSendEvmPermitTransaction;
+    private signAndSendEvmDutchTransaction;
     private signAndSendSubstrateTransaction;
     private signAndSendTonTransaction;
     private signAndSendCardanoTransaction;