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

package/background/KoniTypes.d.ts

@@ -903,6 +903,13 @@ export interface EvmSendTransactionRequest extends TransactionConfig, EvmSignReq
     isToContract: boolean;
     errors?: ErrorValidation[];
 }
+export interface SubmitApiRequest extends EvmSignRequest {
+    id: string;
+    type: string;
+    payload: unknown;
+    errors?: ErrorValidation[];
+    processId?: string;
+}
 export declare enum CardanoProviderErrorType {
     INVALID_REQUEST = "INVALID_REQUEST",
     REFUSED_REQUEST = "REFUSED_REQUEST",
@@ -1014,6 +1021,7 @@ export interface ConfirmationDefinitions {
     evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<string>];
     evmWatchTransactionRequest: [ConfirmationsQueueItem<EvmWatchTransactionRequest>, ConfirmationResult<string>];
     errorConnectNetwork: [ConfirmationsQueueItem<ErrorNetworkConnection>, ConfirmationResult<null>];
+    submitApiRequest: [ConfirmationsQueueItem<SubmitApiRequest>, ConfirmationResult<string>];
 }
 export interface ConfirmationDefinitionsTon {
     tonSignatureRequest: [ConfirmationsQueueItem<TonSignatureRequest>, ConfirmationResult<string>];

package/cjs/koni/background/handlers/Extension.js

@@ -2786,6 +2786,7 @@ class KoniExtension {
     let {
       id
     } = _ref50;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
       transaction,
       ...transactionResult
@@ -2797,6 +2798,7 @@ class KoniExtension {
     function convertRs(rs, processMap) {
       return Object.fromEntries(Object.entries(rs).map(_ref51 => {
         let [key, value] = _ref51;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {
           additionalValidator,
           eventsHandler,
@@ -3854,6 +3856,7 @@ class KoniExtension {
       chainType,
       extrinsic,
       extrinsicType,
+      isDutch,
       isPermit,
       transferNativeAmount,
       txChain,
@@ -3910,6 +3913,24 @@ class KoniExtension {
         step
       });
     }
+    if (isDutch) {
+      return await this.#koniState.transactionService.handleDutchTransaction({
+        address,
+        chain: txChain,
+        transaction: extrinsic,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data: txData,
+        extrinsicType,
+        // change this depends on step
+        chainType,
+        resolveOnDone: !isLastStep,
+        transferNativeAmount,
+        ...this.createPassConfirmationParams(isPassConfirmation),
+        errorOnTimeOut,
+        eventsHandler,
+        step
+      });
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.35-0'
+  version: '1.3.36-0'
 };
 exports.packageInfo = packageInfo;

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;