diff --git a/public/adar/template.csv b/public/adar/template.csv
index 8be3a71af..0167183a6 100644
--- a/public/adar/template.csv
+++ b/public/adar/template.csv
@@ -1,7 +1,2 @@
-//name, wallet address, usd amount, token symbol
-"Ted Cortez",000000000000000000000000000000000000000000000000,10,val
-"Ted Cortez",000000000000000000000000000000000000000000000000,10,xor
-"Honor Pearce",000000000000000000000000000000000000000000000000,1,pswap
-"Rhianna Carpenter",000000000000000000000000000000000000000000000000,10,xor
-"Ali Odonnell",000000000000000000000000000000000000000000000000,1,val
-"Julian Jenkins",000000000000000000000000000000000000000000000000,1,val
\ No newline at end of file
+Melanie Wilson;cnWX1RR9W3iZXtrL5W6WjJoDsWWZHLDCDCMkmWyirHAZJyVu8;2000;XOR
+Charles Scott;cnWX1RR9W3iZXtrL5W6WjJoDsWWZHLDCDCMkmWyirHAZJyVu8;3000;PSWAP
diff --git a/src/components/App/Header/AppHeader.vue b/src/components/App/Header/AppHeader.vue
index 5c6afac0f..910584264 100644
--- a/src/components/App/Header/AppHeader.vue
+++ b/src/components/App/Header/AppHeader.vue
@@ -241,9 +241,7 @@ $app-controls-shadow--dark: inset 1px 1px 2px #52523d;
     margin-left: auto;
   }
 
-  @include desktop {
-    margin-left: auto;
-  }
+  margin-left: auto;
 
   &--moonpay {
     margin-left: auto;
diff --git a/src/components/App/Menu/AppMenu.vue b/src/components/App/Menu/AppMenu.vue
index 632ecb85a..5cbaf68f6 100644
--- a/src/components/App/Menu/AppMenu.vue
+++ b/src/components/App/Menu/AppMenu.vue
@@ -1,7 +1,12 @@
 <template>
   <s-scrollbar
     class="app-menu app-sidebar-scrollbar"
-    :class="{ visible, 'app-menu__about': isAboutPageOpened, 'app-menu__loading': pageLoading }"
+    :class="{
+      visible,
+      'app-menu__about': isAboutPageOpened,
+      'app-menu__loading': pageLoading,
+      'app-menu__route-assets': isRouteAssetsPage,
+    }"
   >
     <aside class="app-sidebar">
       <slot name="head"></slot>
@@ -95,6 +100,7 @@ import {
 
 import { lazyComponent } from '@/router';
 import { getter, state } from '@/store/decorators';
+import { AdarPageNames } from '@/modules/ADAR/consts';
 import { DemeterPageNames } from '@/modules/demeterFarming/consts';
 
 @Component({
@@ -149,6 +155,10 @@ export default class AppMenu extends Mixins(TranslationMixin) {
     this.$emit('open-download-dialog');
   }
 
+  get isRouteAssetsPage(): boolean {
+    return this.$route.name === AdarPageNames.RouteAssets;
+  }
+
   /** To ignore left click */
   preventAnchorNavigation(e?: Event): void {
     e?.preventDefault();
@@ -317,6 +327,11 @@ export default class AppMenu extends Mixins(TranslationMixin) {
       }
     }
 
+    &__route-assets {
+      @include tablet {
+        position: relative;
+      }
+    }
     &__loading {
       z-index: $app-above-loader-layer;
     }
diff --git a/src/lang/en.json b/src/lang/en.json
index a2a59da33..29717b320 100644
--- a/src/lang/en.json
+++ b/src/lang/en.json
@@ -1050,12 +1050,31 @@
                     "assets": "Assets",
                     "usd": "usd",
                     "wallets": "wallets",
-                    "amount": "amount",
+                    "amount": "ESTIMATED AMOUNTS",
+                    "calculated": "calculated",
+                    "issues": "issues found",
+                    "payeers": "payeers",
+                    "processing": "processing",
+                    "waiting": "waiting",
                     "title": "Process routing template",
-                    "description": "Our system is processing your uploaded Routing Template"
+                    "description": "Our system is processing your uploaded Routing Template",
+                    "fixButton": "fix issues"
+                }
+            },
+            "dialogs": {
+                "fixIssuesDialog": {
+                    "title": "Fix or remove issues",
+                    "recipient": "recipient",
+                    "wallets": "wallets",
+                    "fieldStatusCorrect": "{field} correct",
+                    "fieldStatusIncorrect": "{field} incorrect",
+                    "usd": "usd",
+                    "assets": "Assets",
+                    "amount": "estimated amount",
+                    "fixButton": "fix issue",
+                    "deleteButton": "delete recipient"
                 }
             },
-            "dialogs": {},
             "messages": {}
         }
     },    
diff --git a/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue b/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
index 08ee866ff..03901ee6d 100644
--- a/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
+++ b/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
@@ -45,21 +45,44 @@
           </div>
           <warning-message
             class="warning-message"
-            :text="noIssues ? 'ALL ISSUES ARE FIXED' : 'insufficient funds'"
+            :text="noIssues ? 'balance is ok' : 'insufficient funds'"
             :isError="!noIssues"
           />
         </div>
-        <s-divider />
-        <div class="field" v-if="!noIssues">
-          <div class="field__label">remaining AMOUNT required</div>
-          <div class="field__value">
-            <s-button type="primary" class="s-typography-button--mini add-button" @click.stop="onAddFundsClick">
-              {{ 'Add' }}
-            </s-button>
-            {{ formatNumber(remainingAmountRequired) }}
-            <token-logo class="token-logo" :token="inputToken" />
+        <template v-if="!noIssues">
+          <s-divider />
+          <div class="field">
+            <div class="field__label">remaining AMOUNT required</div>
+            <div class="field__value">
+              <s-button
+                type="primary"
+                class="s-typography-button--mini add-button"
+                @click.stop="onAddFundsClick('routing')"
+              >
+                {{ 'Add' }}
+              </s-button>
+              {{ formatNumber(remainingAmountRequired) }}
+              <token-logo class="token-logo" :token="inputToken" />
+            </div>
           </div>
-        </div>
+        </template>
+        <template v-if="showXorRequiredField">
+          <s-divider />
+          <div class="field">
+            <div class="field__label">XOR fee required</div>
+            <div class="field__value">
+              <s-button
+                type="primary"
+                class="s-typography-button--mini add-button"
+                @click.stop="onAddFundsClick('fee')"
+              >
+                {{ 'Add' }}
+              </s-button>
+              {{ formatNumber(xorFeeRequired) }}
+              <token-logo class="token-logo" :token="xor" />
+            </div>
+          </div>
+        </template>
         <s-divider v-if="!noIssues" />
         <div class="buttons-container">
           <s-button type="primary" class="s-typography-button--big" :disabled="!noIssues" @click.stop="onContinueClick">
@@ -87,12 +110,12 @@
         <s-divider />
         <div class="field">
           <div class="field__label">token AMOUNT required</div>
-          <div class="field__value">{{ formatNumber(assetData.total) }}</div>
-          <div class="field__value usd">{{ formatNumber(assetData.usd) }}</div>
+          <div class="field__value">{{ formatNumberJs(assetData.total) }}</div>
+          <div class="field__value usd">{{ formatNumberJs(assetData.usd) }}</div>
         </div>
       </div>
     </div>
-    <swap-dialog :visible.sync="showSwapDialog"></swap-dialog>
+    <swap-dialog :visible.sync="showSwapDialog" :presetSwapData="swapData"></swap-dialog>
     <select-input-asset-dialog
       :visible.sync="showSelectInputAssetDialog"
       @onInputAssetSelected="onInputAssetSelected"
@@ -102,19 +125,18 @@
 
 <script lang="ts">
 import { Component, Mixins } from 'vue-property-decorator';
-import { Components } from '@/consts';
 import { AdarComponents } from '@/modules/ADAR/consts';
-import { lazyComponent } from '@/router';
 import { adarLazyComponent } from '@/modules/ADAR/router';
-import TranslationMixin from '@/components/mixins/TranslationMixin';
 import { action, getter, state } from '@/store/decorators';
-import { components, mixins, SUBQUERY_TYPES } from '@soramitsu/soraneo-wallet-web';
+import { components, mixins } from '@soramitsu/soraneo-wallet-web';
 import { groupBy, sumBy } from 'lodash';
-import { Recipient } from '@/store/routeAssets/types';
-import { CodecString, FPNumber } from '@sora-substrate/util/build';
+import type { PresetSwapData, Recipient } from '@/store/routeAssets/types';
+import { CodecString, FPNumber, NetworkFeesObject, Operation } from '@sora-substrate/util/build';
 import { AccountAsset, Asset } from '@sora-substrate/util/build/assets/types';
-import { formatAssetBalance, getAssetBalance } from '@/utils';
+import { getAssetBalance } from '@/utils';
 import WarningMessage from '../WarningMessage.vue';
+import { XOR, VAL } from '@sora-substrate/util/build/assets/consts';
+import { ZeroStringValue } from '@/consts';
 @Component({
   components: {
     TokenLogo: components.TokenLogo,
@@ -132,6 +154,8 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
   @action.routeAssets.setInputToken setInputToken!: (asset: Asset) => void;
   @action.routeAssets.cancelProcessing private cancelProcessing!: () => void;
   @action.routeAssets.runAssetsRouting private runAssetsRouting!: any;
+  @state.wallet.settings.networkFees private networkFees!: NetworkFeesObject;
+  @getter.assets.xor xor!: Nullable<AccountAsset>;
 
   showSwapDialog = false;
   showSelectInputAssetDialog = false;
@@ -142,24 +166,53 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
   }
 
   get noIssues() {
-    return this.remainingAmountRequired <= 0;
+    return this.remainingAmountRequired.toNumber() <= 0;
   }
 
   get usdToBeRouted() {
-    return this.formatNumber(this.recipients?.reduce((partialSum, a) => partialSum + Number(a.usd), 0));
+    return this.formatNumber(new FPNumber(this.recipients?.reduce((partialSum, a) => partialSum + Number(a.usd), 0)));
   }
 
   get estimatedAmount() {
-    const sum = sumBy(this.summaryData, (item) => item.required);
-    return sum * 1.05;
+    const sum = sumBy(this.summaryData, (item) => item.required) * 1.05;
+    const isInputAssetXor = this.inputToken?.symbol === XOR.symbol;
+    return isInputAssetXor ? new FPNumber(sum).add(this.xorFeeAmount) : new FPNumber(sum);
   }
 
   get totalTokensAvailable() {
     return this.formattedBalance;
   }
 
+  get xorNetworkFee() {
+    return FPNumber.fromCodecValue(this.networkFees[Operation.SwapAndSend]).toNumber();
+  }
+
   get remainingAmountRequired() {
-    return this.estimatedAmount - this.fpBalance.toNumber();
+    const isInputAssetXor = this.inputToken?.symbol === XOR.symbol;
+    return isInputAssetXor
+      ? this.estimatedAmount.add(this.xorFeeAmount).sub(this.fpBalance)
+      : this.estimatedAmount.sub(this.fpBalance);
+  }
+
+  get xorFeeAmount() {
+    return this.summaryData.reduce((sum, item) => {
+      const isTransfer = item.asset.address === this.inputToken.address;
+      const fee = isTransfer ? this.networkFees[Operation.Transfer] : this.networkFees[Operation.SwapAndSend];
+      return sum.add(FPNumber.fromCodecValue(fee));
+    }, FPNumber.ZERO);
+  }
+
+  get xorFeeRequired() {
+    return this.xorFeeAmount.mul(new FPNumber(1.05)).sub(this.xorBalance);
+  }
+
+  get showXorRequiredField() {
+    return this.xorFeeAmount > this.xorBalance && this.inputToken.address !== XOR.address;
+  }
+
+  get xorBalance() {
+    const xorBalance = this.xor?.balance;
+    return this.getFPNumberFromCodec(xorBalance?.transferable ?? ZeroStringValue, this.xor?.decimals);
   }
 
   get summaryData() {
@@ -181,6 +234,40 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
     });
   }
 
+  action: 'fee' | 'routing' = 'fee';
+
+  get routingSwapData(): PresetSwapData {
+    const isInputAssetXor = this.inputToken?.symbol === XOR?.symbol;
+    const assetFrom = isInputAssetXor ? VAL : XOR;
+    const assetTo = this.inputToken;
+    const valueTo = this.remainingAmountRequired.toNumber();
+    return {
+      assetFrom,
+      assetTo,
+      valueTo,
+    };
+  }
+
+  get xorFeeSwapData(): PresetSwapData {
+    const assetFrom = VAL;
+    const assetTo = XOR;
+    const valueTo = this.xorFeeRequired.toNumber();
+    return {
+      assetFrom,
+      assetTo,
+      valueTo,
+    };
+  }
+
+  get swapData(): PresetSwapData {
+    return this.action === 'fee' ? this.xorFeeSwapData : this.routingSwapData;
+  }
+
+  onAddFundsClick(action: 'fee' | 'routing') {
+    this.action = action;
+    this.showSwapDialog = true;
+  }
+
   get fpBalance(): FPNumber {
     if (!this.getTokenBalance) return FPNumber.ZERO;
 
@@ -198,7 +285,7 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
   }
 
   getAssetUSDPrice(asset: Asset) {
-    return FPNumber.fromCodecValue(this.fiatPriceObject[asset.address] ?? 0, 18);
+    return FPNumber.fromCodecValue(this.fiatPriceObject[asset.address] ?? 0, asset.decimals);
   }
 
   get getTokenBalance(): CodecString {
@@ -206,7 +293,7 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
     return getAssetBalance(asset);
   }
 
-  formatNumber(num) {
+  formatNumberJs(num) {
     return !num || !Number.isFinite(num)
       ? '-'
       : num.toLocaleString('en-US', {
@@ -214,10 +301,18 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
         });
   }
 
-  onAddFundsClick() {
-    this.showSwapDialog = true;
+  formatNumber(num: FPNumber) {
+    return !num || !num.isFinity()
+      ? '-'
+      : num.toNumber().toLocaleString('en-US', {
+          maximumFractionDigits: 4,
+        });
   }
 
+  // onAddFundsClick() {
+  //   this.showSwapDialog = true;
+  // }
+
   cancelButtonAction() {
     this.cancelProcessing();
   }
diff --git a/src/modules/ADAR/components/RouteAssets/SwapDialog.vue b/src/modules/ADAR/components/RouteAssets/SwapDialog.vue
index d506ff54b..0755ae31f 100644
--- a/src/modules/ADAR/components/RouteAssets/SwapDialog.vue
+++ b/src/modules/ADAR/components/RouteAssets/SwapDialog.vue
@@ -1,22 +1,67 @@
 <template>
   <div class="swap-dialog">
     <dialog-base :visible.sync="isVisible" :title="'Swap'" custom-class="dialog__swap">
-      <Swap />
+      <Swap ref="swap" />
     </dialog-base>
   </div>
 </template>
 
 <script lang="ts">
-import { Component, Mixins } from 'vue-property-decorator';
+import { Component, Mixins, Prop, Watch } from 'vue-property-decorator';
 import { mixins, components } from '@soramitsu/soraneo-wallet-web';
 import Swap from '@/views/Swap.vue';
+import type { PresetSwapData } from '@/store/routeAssets/types';
+import { FPNumber, NetworkFeesObject, Operation } from '@sora-substrate/util/build';
+import { state } from '@/store/decorators';
+import { XOR } from '@sora-substrate/util/build/assets/consts';
 @Component({
   components: {
     DialogBase: components.DialogBase,
     Swap,
   },
 })
-export default class SwapDialog extends Mixins(mixins.TransactionMixin, mixins.DialogMixin) {}
+export default class SwapDialog extends Mixins(mixins.TransactionMixin, mixins.DialogMixin) {
+  @state.wallet.settings.networkFees private networkFees!: NetworkFeesObject;
+
+  @Prop({ default: 0 }) presetSwapData!: PresetSwapData;
+
+  get presetDataValueTo() {
+    return this.presetSwapData?.valueTo;
+  }
+
+  roundNumber(num) {
+    return Math.ceil((num + Number.EPSILON) * 100) / 100;
+  }
+
+  get networkSwapFee(): number {
+    return FPNumber.fromCodecValue(this.networkFees[Operation.Swap]).toNumber() * 2;
+  }
+
+  @Watch('visible')
+  onVisibleChanged(newVal) {
+    if (newVal) {
+      this.$nextTick(async () => {
+        const swapComponent = this.$refs.swap as any;
+        if (swapComponent) {
+          const { assetFrom, assetTo, valueTo } = this.presetSwapData;
+          const isAssetToXor = assetTo.symbol === XOR.symbol;
+          const fieldToValue = isAssetToXor ? valueTo + this.networkSwapFee : valueTo;
+          swapComponent.handleInputFieldTo(`${this.roundNumber(fieldToValue)}`);
+          await swapComponent.setTokenFromAddress(assetFrom.address);
+          await swapComponent.setTokenToAddress(assetTo.address);
+          swapComponent.handleFocusField(true);
+        }
+      });
+    }
+  }
+
+  @Watch('presetDataValueTo', { deep: true })
+  onValueToChanged(newVal) {
+    if (newVal <= 0) {
+      this.$emit('update:visible', false);
+    }
+  }
+}
 </script>
 
 <style lang="scss">
diff --git a/src/store/routeAssets/actions.ts b/src/store/routeAssets/actions.ts
index 29ef77557..24c2d9e8b 100644
--- a/src/store/routeAssets/actions.ts
+++ b/src/store/routeAssets/actions.ts
@@ -33,12 +33,12 @@ const actions = defineActions({
     dispatch.subscribeOnReserves();
   },
   cancelProcessing(context) {
-    const { commit, rootGetters, dispatch } = routeAssetsActionContext(context);
+    const { commit, dispatch } = routeAssetsActionContext(context);
     dispatch.cleanSwapReservesSubscription();
     commit.clearData();
   },
   async updateRecipients(context, file?: File): Promise<void> {
-    const { commit, rootGetters, dispatch, rootState } = routeAssetsActionContext(context);
+    const { commit, dispatch, rootState } = routeAssetsActionContext(context);
     if (!file) {
       commit.clearData();
       return;
@@ -99,7 +99,7 @@ const actions = defineActions({
   },
 
   deleteRecipient(context, id): void {
-    const { commit, rootState } = routeAssetsActionContext(context);
+    const { commit } = routeAssetsActionContext(context);
     commit.deleteRecipient(id);
   },
 
@@ -149,7 +149,7 @@ const actions = defineActions({
   },
 
   async setSubscriptionPayload(context, { data, inputAssetId, outputAssetId }): Promise<void> {
-    const { state, rootState, getters, commit, dispatch } = routeAssetsActionContext(context);
+    const { state, dispatch } = routeAssetsActionContext(context);
 
     const { dexId, payload } = data;
     // tbc & xst is enabled only on dex 0
@@ -249,11 +249,8 @@ const actions = defineActions({
       });
       return getTransferParams(context, inputAsset, recipient);
     });
-    const transfers = data.filter((item) => item?.transfer);
-    const swapAndSend = data.filter((item) => !item?.transfer);
 
-    await executeBatchSwapAndSend(context, swapAndSend);
-    await executeTransfer(context, transfers);
+    await executeBatchSwapAndSend(context, data);
   },
 
   cleanSwapReservesSubscription(context): void {
@@ -273,7 +270,7 @@ function getAssetUSDPrice(asset, fiatPriceObject) {
 }
 
 function getTransferParams(context, inputAsset, recipient) {
-  const { rootState, getters, rootGetters } = routeAssetsActionContext(context);
+  const { rootState } = routeAssetsActionContext(context);
   if (recipient.asset.address === inputAsset.address) {
     const priceObject = rootState.wallet.account.fiatPriceObject;
     const amount = Number(recipient.usd) / Number(getAssetUSDPrice(recipient.asset, priceObject));
@@ -298,53 +295,19 @@ function getTransferParams(context, inputAsset, recipient) {
         extrinsic: transfer,
         history: history,
       },
+      swapAndSendData: {
+        address: recipient.wallet,
+        targetAmount: amount,
+        asset: recipient.asset,
+        // dexId: bestDexId,
+      },
     };
   } else {
-    const subscription = getters.subscriptions.find((sub) => sub.assetAddress === recipient.asset.address);
-    if (!subscription) return null;
-    const { paths, payload, liquiditySources, dexQuoteData } = subscription;
-    const tokenEquivalent =
-      Number(recipient.usd) /
-      Number(FPNumber.fromCodecValue(rootState.wallet.account.fiatPriceObject[recipient.asset.address], 18));
-    const dexes = api.dex.dexList;
-
     try {
-      // TODO: [ARCH] Asset -> Asset | AccountAsset
-      const results = dexes.reduce<{ [dexId: number]: SwapResult }>((buffer, { dexId }) => {
-        const swapResult = api.swap.getResult(
-          inputAsset,
-          recipient.asset,
-          `${tokenEquivalent}`,
-          true,
-          [rootGetters.swap.swapLiquiditySource].filter(Boolean) as Array<LiquiditySourceTypes>,
-          (dexQuoteData as Record<DexId, DexQuoteData>)[dexId].paths,
-          (dexQuoteData as Record<DexId, DexQuoteData>)[dexId].payload as QuotePayload,
-          dexId as DexId
-        );
-
-        return { ...buffer, [dexId]: swapResult };
-      }, {});
-
-      let bestDexId: number = DexId.XOR;
-
-      for (const currentDexId in results) {
-        const currAmount = FPNumber.fromCodecValue(results[currentDexId].amount);
-        const bestAmount = FPNumber.fromCodecValue(results[bestDexId].amount);
-
-        if (currAmount.isZero()) continue;
-
-        if (
-          FPNumber.isLessThan(currAmount, bestAmount)
-          // &&
-          // this.isExchangeB
-          // ||
-          // (FPNumber.isLessThan(bestAmount, currAmount) && !this.isExchangeB)
-        ) {
-          bestDexId = +currentDexId;
-        }
-      }
-
-      const { amount, amountWithoutImpact, fee, rewards } = results[bestDexId];
+      const swapData = getAmountAndDexId(context, inputAsset, recipient.asset, recipient.usd);
+      if (!swapData) return null;
+
+      const { amountFrom, amountTo, bestDexId } = swapData;
 
       return {
         action: async () =>
@@ -352,8 +315,8 @@ function getTransferParams(context, inputAsset, recipient) {
             recipient.wallet,
             inputAsset,
             recipient.asset,
-            amount,
-            tokenEquivalent,
+            amountFrom,
+            amountTo,
             undefined,
             true,
             undefined,
@@ -361,7 +324,8 @@ function getTransferParams(context, inputAsset, recipient) {
           ),
         swapAndSendData: {
           address: recipient.wallet,
-          targetAmount: tokenEquivalent,
+          targetAmount: amountTo,
+          amountFrom,
           asset: recipient.asset,
           dexId: bestDexId,
         },
@@ -370,9 +334,6 @@ function getTransferParams(context, inputAsset, recipient) {
       };
     } catch (error: any) {
       throw new Error(error);
-      return {
-        recipient,
-      };
     }
   }
 }
@@ -413,126 +374,89 @@ function getTransferParams(context, inputAsset, recipient) {
 // ______________________________________________________________________
 
 async function executeBatchSwapAndSend(context, data: Array<any>): Promise<any> {
-  const { commit, getters, rootCommit } = routeAssetsActionContext(context);
+  const { commit, getters, rootCommit, rootState } = routeAssetsActionContext(context);
   const inputAsset = getters.inputToken;
-  const groupedData = Object.values(groupBy(data, 'assetAddress'));
-  const processArrayData = groupedData.map((recipients) => {
-    const recievers = recipients.map((item) => {
-      const decimals = item.swapAndSendData.asset.decimals;
-      const targetAmount = new FPNumber(item.swapAndSendData.targetAmount, decimals).toCodecString();
-      return {
-        accountId: item.swapAndSendData.address,
-        targetAmount,
-        recipientId: item.recipient.id,
-        targetAmountNum: Number(item.swapAndSendData.targetAmount),
-        dexId: item.swapAndSendData.dexId,
-      };
-    });
-    const maxInputAmount = getAssetBalance(inputAsset);
-    const outputAsset = recipients[0].swapAndSendData.asset;
-    if (!api.assets.getAsset(outputAsset.address)) {
-      api.assets.addAccountAsset(outputAsset.address);
-    }
-    const dexId = recievers[0].dexId;
-    const options = {
-      approxSum: sumBy(recievers, (item: any) => item.targetAmountNum),
-      outputAsset,
+  const newData = data.map((item) => {
+    const decimals = item.swapAndSendData.asset.decimals;
+    const targetAmount = new FPNumber(item.swapAndSendData.targetAmount, decimals).toCodecString();
+    return {
+      accountId: item.swapAndSendData.address,
+      targetAmount,
+      assetAddress: item.swapAndSendData.asset.address,
+      recipientId: item.recipient.id,
+      usd: item.recipient.usd,
     };
+  });
+  const groupedData = Object.entries(groupBy(newData, 'assetAddress'));
+  const assetsTable = rootState.wallet.account.whitelistArray;
+  const findAsset = (assetName: string) => {
+    return assetsTable.find((item: Asset) => item.address === assetName);
+  };
+  const swapTransferData = groupedData.map((entry) => {
+    const [outcomeAssetId, receivers] = entry;
+    const approxSum = sumBy(receivers, (receiver) => receiver.usd);
+    const dexIdData = getAmountAndDexId(context, inputAsset, findAsset(outcomeAssetId) as Asset, approxSum);
+    const dexId = dexIdData?.bestDexId;
     return {
-      recievers,
-      params: calcTxParams(inputAsset, outputAsset, maxInputAmount, undefined, dexId),
-      options,
+      outcomeAssetId,
+      receivers,
+      dexId,
     };
   });
 
   // const formattedToAddress = receiver.slice(0, 2) === 'cn' ? receiver : this.root.formatAddress(receiver);
-
-  async function processArray(transactions) {
-    for (const tx of transactions) {
-      await withLoading(async () => {
-        try {
-          const { params, options } = tx;
-          const time = Date.now();
-          await api
-            .submitExtrinsic(
-              (api.api.tx.liquidityProxy as any).swapTransferBatch(tx.recievers, ...params.args),
-              api.account.pair,
-              {
-                symbol: inputAsset.symbol,
-                assetAddress: inputAsset.address,
-                amount2: `${options.approxSum.toFixed(6)}`,
-                symbol2: options.outputAsset.symbol,
-                asset2Address: options.outputAsset.address,
-                to: api.account.pair.address,
-                type: Operation.SwapAndSend,
-              }
-            )
-            .then(async () => {
-              const lastTx = await getLastTransaction(time);
-              rootCommit.wallet.transactions.addActiveTx(lastTx.id as string);
-              tx.recievers.forEach((reciever) => {
-                commit.setRecipientTxId({
-                  id: reciever.recipientId,
-                  txId: lastTx.id,
-                });
-              });
-            })
-            .catch((err) => {
-              console.dir(err);
-              tx.recievers.forEach((reciever) => {
-                commit.setRecipientStatus({
-                  id: reciever.recipientId,
-                  status: RecipientStatus.FAILED,
-                });
+  const maxInputAmount = getAssetBalance(inputAsset);
+  const params = calcTxParams(inputAsset, maxInputAmount, undefined);
+  await withLoading(async () => {
+    try {
+      // const { params, options } = tx;
+      const time = Date.now();
+      await api
+        .submitExtrinsic(
+          (api.api.tx.liquidityProxy as any).swapTransferBatch(swapTransferData, ...params.args),
+          api.account.pair,
+          {
+            symbol: inputAsset.symbol,
+            assetAddress: inputAsset.address,
+            to: api.account.pair.address,
+            type: Operation.SwapAndSend,
+          }
+        )
+        .then(async () => {
+          const lastTx = await getLastTransaction(time);
+          rootCommit.wallet.transactions.addActiveTx(lastTx.id as string);
+          swapTransferData.forEach((swapTransferItem) => {
+            swapTransferItem.receivers.forEach((receiver) => {
+              commit.setRecipientTxId({
+                id: receiver.recipientId,
+                txId: lastTx.id,
               });
             });
-        } catch (err) {
+          });
+        })
+        .catch((err) => {
           console.dir(err);
-          tx.recievers.forEach((reciever) => {
-            commit.setRecipientStatus({
-              id: reciever.recipientId,
-              status: RecipientStatus.FAILED,
+          swapTransferData.forEach((swapTransferItem) => {
+            swapTransferItem.receivers.forEach((receiver) => {
+              commit.setRecipientStatus({
+                id: receiver.recipientId,
+                status: RecipientStatus.FAILED,
+              });
             });
           });
-        }
-      });
-    }
-  }
-
-  await processArray(processArrayData);
-}
-
-async function executeTransfer(context, data: Array<any>): Promise<any> {
-  const { commit, rootCommit } = routeAssetsActionContext(context);
-  if (data.length < 1) return;
-  const time = Date.now();
-  await api
-    .submitExtrinsic(api.api.tx.utility.batchAll(data.map((item) => item.transfer.extrinsic)), api.account.pair, {
-      symbol: data[0].recipient.asset.symbol,
-      from: api.account.pair.address,
-      to: api.account.pair.address,
-      assetAddress: data[0].recipient.asset.symbol,
-      type: Operation.Transfer,
-    })
-    .then(async () => {
-      const lastTx = await getLastTransaction(time);
-      rootCommit.wallet.transactions.addActiveTx(lastTx.id as string);
-      data.forEach((reciever) => {
-        commit.setRecipientTxId({
-          id: reciever.recipient.id,
-          txId: lastTx.id,
         });
-      });
-    })
-    .catch((err) => {
-      data.forEach((tr) => {
-        commit.setRecipientStatus({
-          id: tr.recipient.id,
-          status: RecipientStatus.FAILED,
+    } catch (err) {
+      console.dir(err);
+      swapTransferData.forEach((swapTransferItem) => {
+        swapTransferItem.receivers.forEach((receiver) => {
+          commit.setRecipientStatus({
+            id: receiver.recipientId,
+            status: RecipientStatus.FAILED,
+          });
         });
       });
-      throw new Error(err);
-    });
+    }
+  });
 }
 
 async function getLastTransaction(time: number): Promise<any> {
@@ -559,21 +483,19 @@ async function withLoading<T = void>(func: FnWithoutArgs<T> | AsyncFnWithoutArgs
 }
 
 function calcTxParams(
-  assetFrom: Asset | AccountAsset,
-  assetTo: Asset | AccountAsset,
+  asset: Asset | AccountAsset,
   maxAmount: NumberLike,
-  liquiditySource = LiquiditySourceTypes.Default,
-  dexId = DexId.XOR
+  liquiditySource = LiquiditySourceTypes.Default
 ) {
   assert(api.account, Messages.connectWallet);
-  const decimals = assetTo.decimals;
+  const decimals = asset.decimals;
   const amount = FPNumber.fromCodecValue(maxAmount, decimals).toCodecString();
   const liquiditySources = liquiditySource ? [liquiditySource] : [];
   return {
     args: [
-      dexId,
-      assetFrom.address,
-      assetTo.address,
+      // dexId,
+      asset.address,
+      // assetTo.address,
       amount,
       liquiditySources,
       liquiditySource === LiquiditySourceTypes.Default ? 'Disabled' : 'AllowSelected',
@@ -581,4 +503,51 @@ function calcTxParams(
   };
 }
 
+function getAmountAndDexId(context: any, assetFrom: Asset, assetTo: Asset, usd: number) {
+  const { rootState, getters, rootGetters } = routeAssetsActionContext(context);
+  const subscription = getters.subscriptions.find((sub) => sub.assetAddress === assetTo.address);
+  if (!subscription) return null;
+  const { paths, payload, liquiditySources, dexQuoteData } = subscription;
+  const tokenEquivalent = new FPNumber(usd)
+    .div(FPNumber.fromCodecValue(rootState.wallet.account.fiatPriceObject[assetTo.address], assetTo.decimals))
+    .toNumber();
+  const dexes = api.dex.dexList;
+  const results = dexes.reduce<{ [dexId: number]: SwapResult }>((buffer, { dexId }) => {
+    const swapResult = api.swap.getResult(
+      assetFrom,
+      assetTo,
+      `${tokenEquivalent}`,
+      true,
+      [rootGetters.swap.swapLiquiditySource].filter(Boolean) as Array<LiquiditySourceTypes>,
+      (dexQuoteData as Record<DexId, DexQuoteData>)[dexId].paths,
+      (dexQuoteData as Record<DexId, DexQuoteData>)[dexId].payload as QuotePayload,
+      dexId as DexId
+    );
+
+    return { ...buffer, [dexId]: swapResult };
+  }, {});
+
+  let bestDexId: number = DexId.XOR;
+
+  for (const currentDexId in results) {
+    const currAmount = FPNumber.fromCodecValue(results[currentDexId].amount);
+    const bestAmount = FPNumber.fromCodecValue(results[bestDexId].amount);
+
+    if (currAmount.isZero()) continue;
+
+    if (
+      FPNumber.isLessThan(currAmount, bestAmount)
+      // &&
+      // this.isExchangeB
+      // ||
+      // (FPNumber.isLessThan(bestAmount, currAmount) && !this.isExchangeB)
+    ) {
+      bestDexId = +currentDexId;
+    }
+  }
+
+  const { amount, amountWithoutImpact, fee, rewards } = results[bestDexId];
+  return { amountFrom: amount, amountTo: tokenEquivalent, bestDexId, allDexes: results };
+}
+
 export default actions;
diff --git a/src/store/routeAssets/types.ts b/src/store/routeAssets/types.ts
index 0d719e6e5..48053da39 100644
--- a/src/store/routeAssets/types.ts
+++ b/src/store/routeAssets/types.ts
@@ -63,3 +63,9 @@ export type RouteAssetsState = {
   processingState: ProcessingState;
   enabledAssets: PrimaryMarketsEnabledAssets;
 };
+
+export type PresetSwapData = {
+  assetFrom: Asset;
+  assetTo: Asset;
+  valueTo: number;
+};