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

package/page/cardano/cips/cip30.d.ts

@@ -1,22 +1,36 @@
 import { CardanoPaginate, Cbor } from '@subwallet/extension-base/background/KoniTypes';
 import { SendRequest } from '@subwallet/extension-base/page/types';
 export declare class CIP30Api {
-    private sendMessage;
+    private readonly sendMessage;
     constructor(sendMessage: SendRequest);
-    getExtension(): {
-        cip: number;
-    }[];
-    getNetworkId(): Promise<number>;
-    getCollateral(payload: {
-        amount: Cbor;
-    }): Promise<string[] | null>;
-    getUtxos(amount?: Cbor, paginate?: CardanoPaginate): Promise<string[] | null>;
-    getUsedAddresses(): Promise<string[]>;
-    getChangeAddress(): Promise<string>;
-    getUnusedAddresses(): Promise<string[]>;
-    getRewardAddresses(): Promise<string[]>;
-    signTx(tx: Cbor, partialSign?: boolean): Promise<string>;
-    signData(address: string, payload: string): Promise<import("@subwallet/extension-base/background/KoniTypes").ResponseCardanoSignData>;
-    submitTx(tx: Cbor): Promise<string>;
-    getBalance(): Promise<string>;
+    private getExtension;
+    private getNetworkId;
+    private getCollateral;
+    private getUtxos;
+    private getUsedAddresses;
+    private getChangeAddress;
+    private getUnusedAddresses;
+    private getRewardAddresses;
+    private signTx;
+    private signData;
+    private submitTx;
+    private getBalance;
+    get apis(): {
+        getExtension: () => {
+            cip: number;
+        }[];
+        getNetworkId: () => Promise<number>;
+        getCollateral: (payload: {
+            amount: Cbor;
+        }) => Promise<string[] | null>;
+        getUtxos: (amount?: Cbor, paginate?: CardanoPaginate) => Promise<string[] | null>;
+        getUsedAddresses: () => Promise<string[]>;
+        getChangeAddress: () => Promise<string>;
+        getUnusedAddresses: () => Promise<string[]>;
+        getRewardAddresses: () => Promise<string[]>;
+        signTx: (tx: Cbor, partialSign?: boolean) => Promise<string>;
+        signData: (address: string, payload: string) => Promise<import("@subwallet/extension-base/background/KoniTypes").ResponseCardanoSignData>;
+        submitTx: (tx: Cbor) => Promise<string>;
+        getBalance: () => Promise<string>;
+    };
 }

package/page/cardano/cips/cip30.js

@@ -32,7 +32,7 @@ export class CIP30Api {
     return new Promise(resolve => resolve([]));
   }
   async getRewardAddresses() {
-    return new Promise(resolve => resolve([]));
+    return await this.sendMessage('cardano(account.get.reward.address)');
   }
   async signTx(tx, partialSign = false) {
     return await this.sendMessage('cardano(transaction.sign)', {
@@ -52,4 +52,20 @@ export class CIP30Api {
   async getBalance() {
     return await this.sendMessage('cardano(account.get.balance)');
   }
+  get apis() {
+    return {
+      getExtension: () => this.getExtension(),
+      getNetworkId: () => this.getNetworkId(),
+      getCollateral: payload => this.getCollateral(payload),
+      getUtxos: (amount, paginate) => this.getUtxos(amount, paginate),
+      getUsedAddresses: () => this.getUsedAddresses(),
+      getChangeAddress: () => this.getChangeAddress(),
+      getUnusedAddresses: () => this.getUnusedAddresses(),
+      getRewardAddresses: () => this.getRewardAddresses(),
+      signTx: (tx, partialSign = false) => this.signTx(tx, partialSign),
+      signData: (address, payload) => this.signData(address, payload),
+      submitTx: tx => this.submitTx(tx),
+      getBalance: () => this.getBalance()
+    };
+  }
 }

package/page/cardano/index.d.ts

@@ -1,13 +1,29 @@
 import type { CardanoExtensionCIP, CardanoProvider } from '@subwallet/extension-inject/types';
-import { CIP30Api } from '@subwallet/extension-base/page/cardano/cips';
 import { SendRequest } from '@subwallet/extension-base/page/types';
 export default class SubWalletCardanoProvider implements CardanoProvider {
     readonly apiVersion: string;
     readonly icon: string;
     readonly name: string;
     readonly supportedExtensions: CardanoExtensionCIP[];
-    protected sendMessage: SendRequest;
+    private readonly sendMessage;
     constructor(sendMessage: SendRequest);
-    enable(): Promise<Readonly<CIP30Api>>;
-    isEnable(): Promise<boolean>;
+    enable: () => Promise<Readonly<{
+        getExtension: () => {
+            cip: number;
+        }[];
+        getNetworkId: () => Promise<number>;
+        getCollateral: (payload: {
+            amount: string;
+        }) => Promise<string[] | null>;
+        getUtxos: (amount?: string | undefined, paginate?: import("../../background/KoniTypes").CardanoPaginate | undefined) => Promise<string[] | null>;
+        getUsedAddresses: () => Promise<string[]>;
+        getChangeAddress: () => Promise<string>;
+        getUnusedAddresses: () => Promise<string[]>;
+        getRewardAddresses: () => Promise<string[]>;
+        signTx: (tx: string, partialSign?: boolean) => Promise<string>;
+        signData: (address: string, payload: string) => Promise<import("../../background/KoniTypes").ResponseCardanoSignData>;
+        submitTx: (tx: string) => Promise<string>;
+        getBalance: () => Promise<string>;
+    }>>;
+    isEnable: () => Promise<boolean>;
 }

package/page/cardano/index.js

@@ -14,7 +14,7 @@ export default class SubWalletCardanoProvider {
     this.icon = WALLET_ICON;
     this.sendMessage = sendMessage;
   }
-  async enable() {
+  enable = async () => {
     const isEnabled = await this.sendMessage('pub(authorize.tabV2)', {
       origin,
       accountAuthTypes: ['cardano']
@@ -23,12 +23,12 @@ export default class SubWalletCardanoProvider {
       throw new Error('Access to the wallet is denied');
     }
     const CIP30 = new CIP30Api(this.sendMessage);
-    return Object.freeze(CIP30);
-  }
-  async isEnable() {
+    return Object.freeze(CIP30.apis);
+  };
+  isEnable = async () => {
     const accountList = await this.sendMessage('pub(accounts.list)', {
       accountAuthType: 'cardano'
     });
     return accountList.length > 0;
-  }
+  };
 }

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

@@ -43,6 +43,8 @@ export default class AuthRequestHandler {
           evm: existKeyEvmNetworkConnect
         };
         needUpdateAuthList = true;
+      } else if (!value.currentNetworkMap) {
+        value.currentNetworkMap = {};
       }
       acc[key] = {
         ...value

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

@@ -132,14 +132,15 @@ export default class CardanoRequestHandler {
   }
   signMessage(confirmation) {
     const {
-      address,
+      address: addressToSign,
+      currentAddress,
       payload
     } = confirmation.payload;
-    const pair = keyring.getPair(address);
+    const pair = keyring.getPair(currentAddress);
     if (pair.isLocked) {
       keyring.unlockPair(pair.address);
     }
-    return pair.cardano.signMessage(payload, true);
+    return pair.cardano.signMessage(payload, addressToSign);
   }
   signTransactionCardano(confirmation) {
     // alibaba

package/services/request-service/helper/index.js

@@ -46,25 +46,27 @@ export const extractMetadata = store => {
 export const convertAssetToValue = amount => {
   const value = CardanoWasm.Value.new(CardanoWasm.BigNum.from_str('0'));
   const multiAsset = CardanoWasm.MultiAsset.new();
-  for (const item of amount) {
-    if (item.unit === 'lovelace') {
-      value.set_coin(CardanoWasm.BigNum.from_str(item.quantity));
-    } else {
-      const policyIdHex = item.unit.slice(0, 56);
-      const assetNameHex = item.unit.slice(56);
-      const scriptHash = CardanoWasm.ScriptHash.from_bytes(Buffer.from(policyIdHex, 'hex'));
-      const assetName = CardanoWasm.AssetName.new(Buffer.from(assetNameHex, 'hex'));
-      const quantity = CardanoWasm.BigNum.from_str(item.quantity);
-      let assets = multiAsset.get(scriptHash);
-      if (!assets) {
-        assets = CardanoWasm.Assets.new();
+  if (amount !== null && amount !== void 0 && amount.length) {
+    for (const item of amount) {
+      if (item.unit === 'lovelace') {
+        value.set_coin(CardanoWasm.BigNum.from_str(item.quantity));
+      } else {
+        const policyIdHex = item.unit.slice(0, 56);
+        const assetNameHex = item.unit.slice(56);
+        const scriptHash = CardanoWasm.ScriptHash.from_bytes(Buffer.from(policyIdHex, 'hex'));
+        const assetName = CardanoWasm.AssetName.new(Buffer.from(assetNameHex, 'hex'));
+        const quantity = CardanoWasm.BigNum.from_str(item.quantity);
+        let assets = multiAsset.get(scriptHash);
+        if (!assets) {
+          assets = CardanoWasm.Assets.new();
+        }
+        assets.insert(assetName, quantity);
+        multiAsset.insert(scriptHash, assets);
       }
-      assets.insert(assetName, quantity);
-      multiAsset.insert(scriptHash, assets);
     }
-  }
-  if (multiAsset.len() > 0) {
-    value.set_multiasset(multiAsset);
+    if (multiAsset.len() > 0) {
+      value.set_multiasset(multiAsset);
+    }
   }
   return value;
 };

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

@@ -165,6 +165,8 @@ export class SwapBaseHandler {
         if (needEditAmount) {
           bnSendingValue = BigN(selectedQuote.toAmount).multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT); // need to round
         } else {
+          // todo: remove
+          console.log('The code cannot run into here, if it runs into here, pls ask dev to check');
           bnSendingValue = BigN(selectedQuote.toAmount);
         }
       }
@@ -365,8 +367,8 @@ export class SwapBaseHandler {
     if (recipient) {
       const isEvmAddress = isEthereumAddress(recipient);
       const isEvmDestChain = _isChainEvmCompatible(swapToChain);
-      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
-        // todo: update this condition
+      if (isEvmAddress !== isEvmDestChain) {
+        // todo: update condition if support swap chain # EVM or Substrate
         return [new TransactionError(SwapErrorType.INVALID_RECIPIENT)];
       }
     }

package/services/swap-service/handler/uniswap-handler.d.ts

@@ -71,7 +71,7 @@ export declare class UniswapHandler implements SwapBaseInterface {
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     getApprovalStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getApproveSwap(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getApproveBridge(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getApproveBridge(params: OptimalSwapPathParamsV2, isBridgeFirst: boolean): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getPermitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getBridgeStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;

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

@@ -7,6 +7,7 @@ import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core
 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 { getAcrossQuote } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
 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';
@@ -94,7 +95,8 @@ export class UniswapHandler {
     const stepFuncList = [];
     /**
      * approve - permit - swap or
-     * approve - permit - swap - approve - bridge
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
      */
 
     params.path.forEach(step => {
@@ -111,11 +113,26 @@ export class UniswapHandler {
     return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
   async getApprovalStep(params, stepIndex) {
-    if (stepIndex === 0) {
+    /**
+     * Explain: All processes will go through one of below processes. If a step do not have, it returns undefined and
+     * the stepIndex is still counted up
+     *
+     * Processes:
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
+     */
+    const actionList = JSON.stringify(params.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapBridge = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const bridgeSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const isApproveBridge = stepIndex === 3 && swapBridge || stepIndex === 0 && bridgeSwap;
+    const isApproveSwap = stepIndex === 0 && swap || stepIndex === 0 && swapBridge || stepIndex === 2 && bridgeSwap;
+    if (isApproveSwap) {
       return this.getApproveSwap(params);
     }
-    if (stepIndex === 3) {
-      return this.getApproveBridge(params);
+    if (isApproveBridge) {
+      return this.getApproveBridge(params, bridgeSwap);
     }
     return Promise.resolve(undefined);
   }
@@ -196,20 +213,28 @@ export class UniswapHandler {
     };
     return Promise.resolve([submitStep, feeInfo]);
   }
-  async getApproveBridge(params) {
-    const quote = params.selectedQuote;
-    if (!quote) {
+  async getApproveBridge(params, isBridgeFirst) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+    if (!selectedQuote) {
       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);
+    const bridgePairInfo = path.find(action => action.action === DynamicSwapType.BRIDGE);
+    if (!bridgePairInfo || !bridgePairInfo.pair) {
+      return Promise.resolve(undefined);
+    }
+    const _sendingAmount = isBridgeFirst ? request.fromAmount : selectedQuote.toAmount;
+    const sendingAmount = BigNumber(_sendingAmount).multipliedBy(2).toFixed(0, 1); // ensure approve enough amount
+    const senderAddress = request.address;
+    const fromTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.from);
     const fromChainInfo = this.chainService.getChainInfoByKey(_getAssetOriginChain(fromTokenInfo));
     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 toTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.to);
     const toChainInfo = this.chainService.getChainInfoByKey(_getAssetOriginChain(toTokenInfo));
     if (_isNativeToken(fromTokenInfo)) {
       return Promise.resolve(undefined);
@@ -220,9 +245,10 @@ export class UniswapHandler {
     const inputData = {
       destinationTokenInfo: toTokenInfo,
       originTokenInfo: fromTokenInfo,
-      sendingValue: sendingAmount,
+      sendingValue: _sendingAmount,
       sender: senderAddress,
       recipient: senderAddress,
+      // todo: there's a case swap - bridge to another address
       destinationChain: toChainInfo,
       originChain: fromChainInfo
     };
@@ -295,6 +321,10 @@ export class UniswapHandler {
     if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const sendingValue = swapXcm ? BigNumber(request.fromAmount).multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1) : request.fromAmount;
+    const expectedReceive = swapXcm ? BigNumber(selectedQuote.toAmount).multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1) : selectedQuote.toAmount;
     const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
     const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
@@ -304,8 +334,8 @@ export class UniswapHandler {
       type: SwapStepType.SWAP,
       // @ts-ignore
       metadata: {
-        sendingValue: request.fromAmount.toString(),
-        expectedReceive: selectedQuote.toAmount,
+        sendingValue,
+        expectedReceive,
         originTokenInfo,
         destinationTokenInfo,
         sender: _reformatAddressWithChain(request.address, originChain),
@@ -321,6 +351,20 @@ export class UniswapHandler {
       request,
       selectedQuote
     } = params;
+    /**
+     * Explain: All processes will go through one of below processes. If a step do not have, it returns undefined and
+     * the stepIndex is still counted up
+     *
+     * Processes:
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
+     */
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const bridgeSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const swapBridge = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const isBridgeFirst = stepIndex === 1 && bridgeSwap;
+    const isBridgeSecond = stepIndex === 4 && swapBridge;
 
     // stepIndex is not corresponding index in path, because uniswap include approval and permit step
     const bridgePairInfo = path.find(action => action.action === DynamicSwapType.BRIDGE);
@@ -337,9 +381,18 @@ export class UniswapHandler {
     if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
       throw Error('Token or chain not found');
     }
+    let receiverAddress;
+    let mockSendingValue;
     const senderAddress = _reformatAddressWithChain(request.address, fromChainInfo);
-    const receiverAddress = _reformatAddressWithChain(request.recipient || request.address, toChainInfo);
-    const sendingValue = BigNumber(selectedQuote.toAmount).div(1.02).toFixed(0, 1);
+    if (isBridgeFirst) {
+      receiverAddress = _reformatAddressWithChain(request.address, toChainInfo);
+      mockSendingValue = BigNumber(selectedQuote.fromAmount).toFixed(0, 1);
+    } else if (isBridgeSecond) {
+      receiverAddress = _reformatAddressWithChain(request.recipient || request.address, toChainInfo);
+      mockSendingValue = BigNumber(selectedQuote.toAmount).toFixed(0, 1);
+    } else {
+      return undefined;
+    }
     try {
       const evmApi = await this.chainService.getEvmApi(fromChainInfo.slug).isReady;
       const feeInfo = await this.feeService.subscribeChainFee(getId(), fromTokenInfo.originChain, 'evm');
@@ -351,25 +404,37 @@ export class UniswapHandler {
         evmApi,
         feeInfo,
         // Mock sending value to get payment info
-        sendingValue,
+        sendingValue: mockSendingValue,
         sender: senderAddress,
         recipient: receiverAddress
       });
-
-      // // todo: wait until this ready to get destination fee. the real receiveAmount is deduce by this fee
-      // const acrossQuote = await getAcrossQuote({
-      //   destinationChain: toChainInfo,
-      //   destinationTokenInfo: toTokenInfo,
-      //   originChain: fromChainInfo,
-      //   originTokenInfo: fromTokenInfo,
-      //   recipient: receiverAddress,
-      //   sender: senderAddress,
-      //   sendingValue,
-      //   feeInfo
-      // });
-
+      const acrossQuote = await getAcrossQuote({
+        destinationChain: toChainInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        originTokenInfo: fromTokenInfo,
+        recipient: receiverAddress,
+        sender: senderAddress,
+        sendingValue: mockSendingValue,
+        feeInfo
+      });
+      const acrossQuoteMetadata = acrossQuote.metadata;
       const estimatedBridgeFee = await estimateTxFee(tx, evmApi, feeInfo);
-      const expectedReceive = BigNumber(sendingValue).minus(estimatedBridgeFee).toFixed(0, 1);
+      const estimatedDestinationFee = BigNumber(mockSendingValue).minus(acrossQuoteMetadata.outputAmount).toFixed(0, 1); // todo: should better handle on backend and return desFee metadata instead of minus like this
+
+      let sendingValue;
+      let expectedReceive;
+      if (isBridgeFirst) {
+        expectedReceive = selectedQuote.fromAmount;
+        sendingValue = BigNumber(estimatedDestinationFee).multipliedBy(FEE_RATE_MULTIPLIER.medium).plus(selectedQuote.fromAmount).toFixed(0, 1);
+      } else if (isBridgeSecond) {
+        expectedReceive = selectedQuote.toAmount;
+        sendingValue = BigNumber(selectedQuote.toAmount).multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1);
+      } else {
+        return undefined;
+      }
+      console.log('[i] estimatedBridgeFee', estimatedBridgeFee);
+      console.log('[i] estimatedDestinationFee', estimatedDestinationFee);
       const fee = {
         feeComponent: [{
           feeType: SwapFeeType.NETWORK_FEE,
@@ -738,7 +803,7 @@ export class UniswapHandler {
     if (swapIndex <= -1) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
-    if (swapXcm && bridgeIndex <= -1) {
+    if ((swapXcm || xcmSwap) && bridgeIndex <= -1) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (swap) {
@@ -749,7 +814,7 @@ export class UniswapHandler {
       return this.swapBaseHandler.validateSwapXcmProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwap) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateXcmSwapProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwapXcm) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];

package/services/swap-service/index.js

@@ -39,7 +39,7 @@ export class SwapService {
     var _subwalletApiSdk$swap;
     const availableQuotes = [];
 
-    // hotfix
+    // hotfix // todo: remove later
     const request = {
       ..._request,
       isSupportKyberVersion: true

package/types/service-base.d.ts

@@ -20,6 +20,7 @@ export interface CommonFeeComponent {
     feeType: BaseFeeType;
     amount: string;
     tokenSlug: string;
+    percentage?: number;
 }
 export interface CommonStepFeeInfo {
     feeComponent: CommonFeeComponent[];