@subwallet/extension-base 1.3.22-0 → 1.3.24-0

package/services/swap-service/index.js

@@ -12,8 +12,10 @@ import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
 import { _SUPPORTED_SWAP_PROVIDERS, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { BehaviorSubject } from 'rxjs';
 import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
+import { UniswapHandler } from "./handler/uniswap-handler.js";
 export const _isChainSupportedByProvider = (providerSlug, chain) => {
   const supportedChains = _PROVIDER_TO_SUPPORTED_PAIR_MAP[providerSlug];
   return supportedChains ? supportedChains.includes(chain) : false;
@@ -30,31 +32,34 @@ export class SwapService {
     this.chainService = state.chainService;
   }
   async askProvidersForQuote(request) {
+    var _subwalletApiSdk$swap;
     const availableQuotes = [];
-    const swappingSrcChain = this.chainService.getAssetBySlug(request.pair.from).originChain;
     await Promise.all(Object.values(this.handlers).map(async handler => {
       // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
-      if (!_isChainSupportedByProvider(handler.providerSlug, swappingSrcChain)) {
-        return;
-      }
+
       if (handler.init && handler.isReady === false) {
         await handler.init();
       }
-      const quote = await handler.getSwapQuote(request);
-      if (!(quote instanceof SwapError)) {
-        // todo: can do better
-        availableQuotes.push({
-          quote
-        });
-      } else {
-        availableQuotes.push({
-          error: quote
-        });
-      }
     }));
-    return availableQuotes; // todo: need to propagate error for further handling
+    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 (!quoteData.quote || Object.keys(quoteData.quote).length === 0) {
+          return;
+        }
+        if (!('errorClass' in quoteData.quote)) {
+          availableQuotes.push({
+            quote: quoteData.quote
+          });
+        } else {
+          availableQuotes.push({
+            error: new SwapError(quoteData.quote.errorType, quoteData.quote.message)
+          });
+        }
+      });
+    }
+    return availableQuotes;
   }
-
   getDefaultProcess(params) {
     const result = {
       totalFee: [MOCK_STEP_FEE],
@@ -76,7 +81,8 @@ export class SwapService {
     if (!params.selectedQuote) {
       return this.getDefaultProcess(params);
     } else {
-      const providerId = params.selectedQuote.provider.id;
+      var _params$request$curre;
+      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         return handler.generateOptimalProcess(params);
@@ -91,7 +97,6 @@ export class SwapService {
     * 2. Select the best quote
     * 3. Generate optimal process for that quote
     * */
-
     const swapQuoteResponse = await this.getLatestQuotes(request);
     const optimalProcess = await this.generateOptimalProcess({
       request,
@@ -155,15 +160,18 @@ export class SwapService {
         case SwapProviderId.KUSAMA_ASSET_HUB:
           this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'statemine');
           break;
-        case SwapProviderId.ROCOCO_ASSET_HUB:
-          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
-          break;
+        // case SwapProviderId.ROCOCO_ASSET_HUB:
+        //   this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
+        //   break;
         case SwapProviderId.WESTEND_ASSET_HUB:
           this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'westend_assethub');
           break;
         case SwapProviderId.SIMPLE_SWAP:
           this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;
+        case SwapProviderId.UNISWAP:
+          this.handlers[providerId] = new UniswapHandler(this.chainService, this.state.balanceService, this.state.transactionService, this.state.feeService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/services/swap-service/utils.d.ts

@@ -1,13 +1,8 @@
-import { Asset, Chain } from '@chainflip/sdk/swap';
 import { _ChainAsset } from '@subwallet/chain-list/types';
 import { SwapPair } from '@subwallet/extension-base/types/swap';
 export declare const CHAIN_FLIP_TESTNET_EXPLORER = "https://blocks-perseverance.chainflip.io";
 export declare const CHAIN_FLIP_MAINNET_EXPLORER = "https://scan.chainflip.io";
 export declare const SIMPLE_SWAP_EXPLORER = "https://simpleswap.io";
-export declare const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING: Record<string, Chain>;
-export declare const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING: Record<string, Chain>;
-export declare const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING: Record<string, Asset>;
-export declare const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, Asset>;
 export declare const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, string>;
 export declare const SWAP_QUOTE_TIMEOUT_MAP: Record<string, number>;
 export declare const _PROVIDER_TO_SUPPORTED_PAIR_MAP: Record<string, string[]>;
@@ -27,3 +22,4 @@ export declare function getChainflipOptions(isTestnet: boolean): {
 export declare function getChainflipBroker(isTestnet: boolean): {
     url: string;
 };
+export declare function getChainflipSwap(isTestnet: boolean): string;

package/services/swap-service/utils.js

@@ -1,7 +1,6 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { Assets, Chains } from '@chainflip/sdk/swap';
 import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 import { _getAssetDecimals } from '@subwallet/extension-base/services/chain-service/utils';
 import { CHAINFLIP_BROKER_API } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
@@ -10,26 +9,6 @@ import BigN from 'bignumber.js';
 export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
 export const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
 export const SIMPLE_SWAP_EXPLORER = 'https://simpleswap.io';
-export const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
-  [COMMON_CHAIN_SLUGS.POLKADOT]: Chains.Polkadot,
-  [COMMON_CHAIN_SLUGS.ETHEREUM]: Chains.Ethereum,
-  [COMMON_CHAIN_SLUGS.ARBITRUM]: Chains.Arbitrum
-};
-export const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = {
-  [COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]: Chains.Ethereum,
-  [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT]: Chains.Polkadot
-};
-export const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = {
-  [COMMON_ASSETS.DOT]: Assets.DOT,
-  [COMMON_ASSETS.ETH]: Assets.ETH,
-  [COMMON_ASSETS.USDC_ETHEREUM]: Assets.USDC,
-  [COMMON_ASSETS.USDT_ETHEREUM]: Assets.USDT
-};
-export const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
-  [COMMON_ASSETS.PDOT]: Assets.DOT,
-  [COMMON_ASSETS.ETH_SEPOLIA]: Assets.ETH,
-  [COMMON_ASSETS.USDC_SEPOLIA]: Assets.USDC
-};
 export const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
   'bittensor-NATIVE-TAO': 'tao',
   [COMMON_ASSETS.ETH]: 'eth',
@@ -99,4 +78,11 @@ export function getChainflipBroker(isTestnet) {
       url: `https://chainflip-broker.io/rpc/${CHAINFLIP_BROKER_API}`
     };
   }
+}
+export function getChainflipSwap(isTestnet) {
+  if (isTestnet) {
+    return `https://perseverance.chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
+  } else {
+    return `https://chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
+  }
 }

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

@@ -1,4 +1,5 @@
 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 { SubmittableExtrinsic } from '@polkadot/api/promise/types';
@@ -6,4 +7,5 @@ export declare const getTransactionId: (chainType: string, chain: string, isInte
 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;

package/services/transaction-service/helpers/index.js

@@ -17,6 +17,10 @@ export const isTonTransaction = tx => {
   const tonTransactionConfig = tx;
   return Boolean(tonTransactionConfig.messagePayload) && tonTransactionConfig.seqno >= 0;
 };
+export const isCardanoTransaction = tx => {
+  const cardanoTransactionConfig = tx;
+  return cardanoTransactionConfig.cardanoPayload !== null && cardanoTransactionConfig.cardanoPayload !== undefined;
+};
 const typeName = type => {
   switch (type) {
     case ExtrinsicType.TRANSFER_BALANCE:

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

@@ -1,7 +1,7 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { SWTransaction, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
-import { BriefProcessStep, ProcessStep, ProcessTransactionData } from '@subwallet/extension-base/types';
+import { SWPermitTransactionInput, SWTransaction, 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';
 import { HexString } from '@polkadot/util/types';
@@ -15,6 +15,7 @@ export default class TransactionService {
     private aliveProcessMap;
     private readonly transactionSubject;
     private readonly aliveProcessSubject;
+    private cacheProcessInfo;
     private get transactions();
     constructor(state: KoniState);
     private get allTransactions();
@@ -31,12 +32,15 @@ export default class TransactionService {
         readonly transaction: Record<string, SWTransaction>;
         readonly aliveProcess: Record<string, ProcessTransactionData>;
     };
+    getCacheInfo(processId: string, step: BaseStepType): string;
     private updateAliveProcess;
     private fillTransactionDefaultInfo;
     addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;
     generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
     handleTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
+    handlePermitTransaction(transaction: SWPermitTransactionInput): Promise<SWTransactionResponse>;
     private sendTransaction;
+    private sendPermitTransaction;
     private removeTransaction;
     private updateTransaction;
     private getTransactionLink;
@@ -50,8 +54,10 @@ export default class TransactionService {
     private onTimeOut;
     generateHashPayload(chain: string, transaction: TransactionConfig): HexString;
     private signAndSendEvmTransaction;
+    private signAndSendEvmPermitTransaction;
     private signAndSendSubstrateTransaction;
     private signAndSendTonTransaction;
+    private signAndSendCardanoTransaction;
     private handleTransactionTimeout;
     private handlePostEarningTransaction;
     createProcessIfNeed(process: ProcessTransactionData): Promise<void>;

package/services/transaction-service/index.js

@@ -4,14 +4,14 @@
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
-import { ALL_ACCOUNT_KEY, fetchBlockedConfigObjects, fetchLastestBlockedActionsAndFeatures, getPassConfigId } from '@subwallet/extension-base/constants';
+import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, fetchBlockedConfigObjects, fetchLastestBlockedActionsAndFeatures, getPassConfigId } from '@subwallet/extension-base/constants';
 import { checkBalanceWithTransactionFee, checkSigningAccountForTransaction, checkSupportForAction, checkSupportForFeature, checkSupportForTransaction, estimateFeeForTransaction } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { cellToBase64Str, externalMessage, getTransferCellPromise } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible, _isNativeTokenBySlug } from '@subwallet/extension-base/services/chain-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
-import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { getBaseTransactionInfo, getTransactionId, isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { BasicTxErrorType, StepStatus, YieldPoolType } from '@subwallet/extension-base/types';
@@ -33,6 +33,7 @@ export default class TransactionService {
   aliveProcessMap = new Map();
   transactionSubject = new BehaviorSubject({});
   aliveProcessSubject = new BehaviorSubject(this.aliveProcessMap);
+  cacheProcessInfo = {};
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -89,8 +90,6 @@ export default class TransactionService {
       checkSupportForAction(validationResponse, blockedActionsMap);
     }
     const transaction = transactionInput.transaction;
-    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
-    const tokenPayFeeInfo = transactionInput.nonNativeTokenPayFeeSlug ? this.chainService.getAssetBySlug(transactionInput.nonNativeTokenPayFeeSlug) : undefined;
 
     // Check duplicated transaction
     validationResponse.errors.push(...this.checkDuplicate(transactionInput));
@@ -103,16 +102,25 @@ export default class TransactionService {
     const substrateApi = this.state.chainService.getSubstrateApi(chainInfo.slug);
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
-    const isNoEvmApi = transaction && !isSubstrateTransaction(transaction) && !isTonTransaction(transaction) && !evmApi; // todo: should split isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api
+    const cardanoApi = this.state.chainService.getCardanoApi(chainInfo.slug);
+    // todo: should split into isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api. Same to all blockchain.
+    // todo: refactor check evmTransaction.
+    const isNoEvmApi = transaction && !isSubstrateTransaction(transaction) && !isTonTransaction(transaction) && !isCardanoTransaction(transaction) && !evmApi;
     const isNoTonApi = transaction && isTonTransaction(transaction) && !tonApi;
-    if (isNoEvmApi || isNoTonApi) {
+    const isNoCardanoApi = transaction && isCardanoTransaction(transaction) && !cardanoApi;
+    if (isNoEvmApi || isNoTonApi || isNoCardanoApi) {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     const id = getId();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
-    validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, feeInfo, nativeTokenInfo, tokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
+    const tokenPayFeeSlug = transactionInput.tokenPayFeeSlug;
+    const isNonNativeTokenPayFee = tokenPayFeeSlug && !_isNativeTokenBySlug(tokenPayFeeSlug);
+    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
+    const priceMap = (await this.state.priceService.getPrice()).priceMap;
+    validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
@@ -169,6 +177,10 @@ export default class TransactionService {
       }
     };
   }
+  getCacheInfo(processId, step) {
+    var _this$cacheProcessInf;
+    return ((_this$cacheProcessInf = this.cacheProcessInfo[processId]) === null || _this$cacheProcessInf === void 0 ? void 0 : _this$cacheProcessInf[step]) || '';
+  }
   updateAliveProcess() {
     this.aliveProcessSubject.next(this.aliveProcessMap);
   }
@@ -263,9 +275,61 @@ export default class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handlePermitTransaction(transaction) {
+    var _transaction$step;
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, true);
+    const validatedTransaction = {
+      ...transaction,
+      id: transactionId,
+      extrinsicHash: '',
+      status: undefined,
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
+    };
+    const txInput = {
+      ...transaction,
+      isInternal: true,
+      status: ExtrinsicStatus.QUEUED,
+      id: transactionId,
+      extrinsicHash: transactionId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime()
+    };
+    const _data = transaction.data;
+    const emitter = this.sendPermitTransaction(txInput);
+    await new Promise((resolve, reject) => {
+      emitter.on('success', data => {
+        validatedTransaction.id = data.id;
+        validatedTransaction.extrinsicHash = data.extrinsicHash;
+        this.cacheProcessInfo[_data.processId] = {
+          [_data.step]: data.extrinsicHash
+        };
+        resolve();
+      });
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return validatedTransaction;
+  }
   async sendTransaction(transaction) {
     // Send Transaction
-    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : this.signAndSendTonTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
     const {
       eventsHandler,
       step
@@ -315,7 +379,12 @@ export default class TransactionService {
           }
           return false;
         });
-        if (rejectError) {
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
           this.deleteProcess(step);
         } else {
           this.updateProcessStepStatus(step, {
@@ -341,6 +410,71 @@ export default class TransactionService {
     eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
     return emitter;
   }
+  sendPermitTransaction(transaction) {
+    // Send Transaction
+    const emitter = this.signAndSendEvmPermitTransaction(transaction);
+    const {
+      eventsHandler,
+      step
+    } = transaction;
+    emitter.on('send', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
+    });
+    emitter.on('extrinsicHash', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: StepStatus.PROCESSING
+        });
+      }
+    });
+    emitter.on('success', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: StepStatus.COMPLETE
+        });
+      }
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
+      });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          if ([BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
+            return true;
+          }
+          return false;
+        });
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: StepStatus.FAILED
+          });
+        }
+      }
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
+    return emitter;
+  }
   removeTransaction(id) {
     if (this.transactions[id]) {
       delete this.transactions[id];
@@ -364,7 +498,7 @@ export default class TransactionService {
     return getExplorerLink(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
-    var _transaction$step;
+    var _transaction$step2;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -389,7 +523,7 @@ export default class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
+      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
     };
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
@@ -1156,20 +1290,75 @@ export default class TransactionService {
     }
     return emitter;
   }
+  signAndSendEvmPermitTransaction({
+    address,
+    id,
+    isPassConfirmation,
+    step,
+    transaction,
+    url
+  }) {
+    // Allow sign transaction
+    const canSign = true;
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    const evmSignaturePayload = {
+      id: id,
+      type: 'eth_signTypedData_v4',
+      payload: transaction,
+      address: address,
+      hashPayload: '',
+      canSign: canSign,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSignatureRequest', evmSignaturePayload, {
+      isPassConfirmation
+    }).then(({
+      isApproved,
+      payload: signature
+    }) => {
+      if (isApproved) {
+        // Emit signed event
+        emitter.emit('signed', eventData);
+        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
+
+        if (!signature) {
+          throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Failed to sign'));
+        }
+        eventData.extrinsicHash = signature;
+        emitter.emit('extrinsicHash', eventData);
+        emitter.emit('success', eventData);
+      } else {
+        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, t(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
   signAndSendSubstrateTransaction({
     address,
     chain,
     feeCustom,
     id,
-    nonNativeTokenPayFeeSlug,
     signAfterCreate,
     step,
+    tokenPayFeeSlug,
     transaction,
     url
   }) {
     var _this$state$chainServ;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
-    const feeAssetId = nonNativeTokenPayFeeSlug ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(nonNativeTokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
+    const feeAssetId = tokenPayFeeSlug && !_isNativeTokenBySlug(tokenPayFeeSlug) && _SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(chain) ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
     const emitter = new EventEmitter();
     const eventData = {
       id,
@@ -1313,7 +1502,7 @@ export default class TransactionService {
         });
       });
     };
-    const tonTransactionConfig = transaction;
+    const tonTransactionConfig = transaction; // todo: is this same as payload?
     const seqno = tonTransactionConfig.seqno;
     const messages = tonTransactionConfig.messages;
     const transferObjectPromise = getTransferCellPromise(walletContract, signer, payload, seqno, messages);
@@ -1359,6 +1548,73 @@ export default class TransactionService {
     });
     return emitter;
   }
+  signAndSendCardanoTransaction({
+    chain,
+    id,
+    transaction,
+    url
+  }) {
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const transactionConfig = transaction;
+    const cardanoApi = this.state.chainService.getCardanoApi(chain);
+    this.state.requestService.addConfirmationCardano(id, url || EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (!isApproved) {
+        this.removeTransaction(id);
+        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      } else {
+        if (!payload) {
+          throw new Error('Failed to sign');
+        }
+
+        // Emit signed event
+        emitter.emit('signed', eventData);
+
+        // Send transaction
+        this.handleTransactionTimeout(emitter, eventData);
+        emitter.emit('send', eventData);
+
+        // send qua api
+        cardanoApi.sendCardanoTxReturnHash(payload).then(txHash => {
+          if (!txHash) {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED));
+            emitter.emit('error', eventData);
+          }
+          eventData.extrinsicHash = txHash;
+          emitter.emit('extrinsicHash', eventData);
+
+          // todo: wait transaction by fetch txHash by API
+          cardanoApi.getStatusByTxHash(txHash, transactionConfig.cardanoTtlOffset).then(status => {
+            if (!status) {
+              eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              emitter.emit('error', eventData);
+            }
+            emitter.emit('success', eventData);
+          }).catch(e => {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+            emitter.emit('error', eventData);
+          });
+        }).catch(e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        });
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, t(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
   handleTransactionTimeout(emitter, eventData) {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);
@@ -1501,9 +1757,9 @@ export default class TransactionService {
     }
   }
   async createProcessNotification(transactionId) {
-    var _transaction$step2;
+    var _transaction$step3;
     const transaction = this.getTransaction(transactionId);
-    if (transaction && (_transaction$step2 = transaction.step) !== null && _transaction$step2 !== void 0 && _transaction$step2.processId) {
+    if (transaction && (_transaction$step3 = transaction.step) !== null && _transaction$step3 !== void 0 && _transaction$step3.processId) {
       const process = this.aliveProcessMap.get(transaction.step.processId);
       if (process) {
         await this.state.inappNotificationService.createProcessNotification(process);