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

package/koni/background/handlers/State.js

@@ -41,7 +41,7 @@ import WalletConnectService from '@subwallet/extension-base/services/wallet-conn
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { addLazy, isManifestV3, isSameAddress, reformatAddress, stripUrl, targetIsWeb } from '@subwallet/extension-base/utils';
-import { convertCardanoHexToBech32 } from '@subwallet/extension-base/utils/cardano';
+import { convertCardanoHexToBech32, validateAddressNetwork } from '@subwallet/extension-base/utils/cardano';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { keyring } from '@subwallet/ui-keyring';
@@ -1094,13 +1094,13 @@ export default class KoniState {
     if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
       autoActiveChain = true;
     }
-    const currentEvmNetwork = this.requestService.getDAppChainInfo({
+    const currentCardanoNetwork = this.requestService.getDAppChainInfo({
       autoActive: autoActiveChain,
       accessType: 'cardano',
       defaultChain: networkKey,
       url
     });
-    networkKey = (currentEvmNetwork === null || currentEvmNetwork === void 0 ? void 0 : currentEvmNetwork.slug) || 'cardano';
+    networkKey = (currentCardanoNetwork === null || currentCardanoNetwork === void 0 ? void 0 : currentCardanoNetwork.slug) || 'cardano';
     const allUtxos = await this.chainService.getUtxosByAddress(currentAddress, networkKey);
     const outputTransactionUnSpend = CardanoWasm.TransactionOutputs.new();
     inputs.to_js_value().forEach(input => {
@@ -1137,12 +1137,23 @@ export default class KoniState {
         values: convertValueToAsset(output)
       };
       if (isSameAddress(currentAddress, address)) {
+        if (!validateAddressNetwork(address, currentCardanoNetwork)) {
+          throw new CardanoProviderError(CardanoProviderErrorType.ACCOUNT_CHANGED, t('Current network is changed'));
+        }
         transactionValue = transactionValue.checked_add(amount);
         addressInputAmountMap[address].isOwner = true;
         addressOutputAmountMap[address].isOwner = true;
       }
+
+      // Check if address is valid with current network
+      if (!validateAddressNetwork(address, currentCardanoNetwork)) {
+        throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, t('Current network is not match with input address'));
+      }
     }
     for (const address in addressOutputMap) {
+      if (!validateAddressNetwork(address, currentCardanoNetwork)) {
+        throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, t('Current network is not match with output address'));
+      }
       if (!addressInputAmountMap[address] && !addressOutputMap[address].is_zero()) {
         addressOutputAmountMap[address] = {
           values: convertValueToAsset(addressOutputMap[address]),
@@ -1250,13 +1261,7 @@ export default class KoniState {
   async onMV3Update() {
     const migrationStatus = await SWStorage.instance.getItem('mv3_migration');
     if (!migrationStatus || migrationStatus !== 'done') {
-      if (isManifestV3) {
-        // Open migration tab
-        const url = `${chrome.runtime.getURL('index.html')}#/mv3-migration`;
-        await openPopup(url);
-
-        // migrateMV3LocalStorage will be called when user open migration tab with data from localStorage on frontend
-      } else {
+      if (!isManifestV3) {
         this.migrateMV3LocalStorage(JSON.stringify(self.localStorage)).catch(console.error);
       }
     }

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.35-0",
+  "version": "1.3.37-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1911,6 +1911,11 @@
       "require": "./cjs/services/swap-service/handler/hydradx-handler.js",
       "default": "./services/swap-service/handler/hydradx-handler.js"
     },
+    "./services/swap-service/handler/kyber-handler": {
+      "types": "./services/swap-service/handler/kyber-handler.d.ts",
+      "require": "./cjs/services/swap-service/handler/kyber-handler.js",
+      "default": "./services/swap-service/handler/kyber-handler.js"
+    },
     "./services/swap-service/handler/simpleswap-handler": {
       "types": "./services/swap-service/handler/simpleswap-handler.d.ts",
       "require": "./cjs/services/swap-service/handler/simpleswap-handler.js",
@@ -2705,20 +2710,20 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
     "@subwallet/chain-list": "0.2.104",
-    "@subwallet/extension-base": "^1.3.35-0",
-    "@subwallet/extension-chains": "^1.3.35-0",
-    "@subwallet/extension-dapp": "^1.3.35-0",
-    "@subwallet/extension-inject": "^1.3.35-0",
+    "@subwallet/extension-base": "^1.3.37-0",
+    "@subwallet/extension-chains": "^1.3.37-0",
+    "@subwallet/extension-dapp": "^1.3.37-0",
+    "@subwallet/extension-inject": "^1.3.37-0",
     "@subwallet/keyring": "^0.1.11",
-    "@subwallet/subwallet-api-sdk": "^1.3.35-0",
+    "@subwallet/subwallet-api-sdk": "^1.3.37-0",
     "@subwallet/ui-keyring": "^0.1.11",
     "@ton/core": "^0.56.3",
     "@ton/crypto": "^3.2.0",
     "@ton/ton": "^15.0.0",
     "@walletconnect/keyvaluestorage": "^1.1.1",
-    "@walletconnect/sign-client": "^2.14.0",
-    "@walletconnect/types": "^2.14.0",
-    "@walletconnect/utils": "^2.14.0",
+    "@walletconnect/sign-client": "^2.20.2",
+    "@walletconnect/types": "^2.20.2",
+    "@walletconnect/utils": "^2.20.2",
     "avail-js-sdk": "^0.2.12",
     "axios": "^1.6.2",
     "bignumber.js": "^9.1.1",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.35-0'
+  version: '1.3.37-0'
 };

package/services/chain-service/types.d.ts

@@ -15,8 +15,8 @@ import { ChainProperties, ChainType, RuntimeVersion } from '@polkadot/types/inte
 import { AnyJson, Registry } from '@polkadot/types/types';
 export interface _DataMap {
     chainInfoMap: Record<string, _ChainInfo>;
-    chainStateMap: Record<string, _ChainState>;
     assetRegistry: Record<string, _ChainAsset>;
+    chainStateMap: Record<string, _ChainState>;
     assetRefMap: Record<string, _AssetRef>;
 }
 export declare enum _ChainConnectionStatus {

package/services/event-service/types.d.ts

@@ -1,4 +1,4 @@
-import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
 import { CurrentAccountInfo } from '@subwallet/extension-base/types';
 export interface EventRegistry {
     'general.sleep': [boolean];
@@ -27,13 +27,13 @@ export interface EventRegistry {
     'asset.ready': [boolean];
     'asset.online.ready': [boolean];
     'asset.updateState': [string];
-    'transaction.done': [SWTransaction];
-    'transaction.failed': [SWTransaction | undefined];
-    'transaction.timeout': [SWTransaction | undefined];
+    'transaction.done': [SWTransactionBase];
+    'transaction.failed': [SWTransactionBase | undefined];
+    'transaction.timeout': [SWTransactionBase | undefined];
     'transaction.submitStaking': [string];
-    'transaction.transferNft': [SWTransaction | undefined];
+    'transaction.transferNft': [SWTransactionBase | undefined];
     'mantaPay.initSync': [string | undefined];
-    'mantaPay.submitTransaction': [SWTransaction | undefined];
+    'mantaPay.submitTransaction': [SWTransactionBase | undefined];
     'mantaPay.enable': [string];
     'migration.done': [boolean];
     'campaign.ready': [boolean];

package/services/request-service/handler/AuthRequestHandler.js

@@ -260,7 +260,10 @@ export default class AuthRequestHandler {
           origin,
           url,
           accountAuthTypes: [...new Set([...accountAuthTypes, ...((existed === null || existed === void 0 ? void 0 : existed.accountAuthTypes) || [])])],
-          currentNetworkMap: existed ? existed.currentNetworkMap : defaultNetworkMap
+          currentNetworkMap: existed ? {
+            ...defaultNetworkMap,
+            ...existed.currentNetworkMap
+          } : defaultNetworkMap
         };
         this.setAuthorize(authorizeList, () => {
           cb();

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 {};