From d29d05bfdc414842df2c4cea0e1f6ed85239fca5 Mon Sep 17 00:00:00 2001
From: Timofey Trepalin <trepalin@soramitsu.co.jp>
Date: Tue, 7 Feb 2023 14:07:52 +0500
Subject: [PATCH 1/5] swap dialog fixes - bugs 86, 87, 61

---
 public/adar/template.csv                      |  9 +---
 src/components/App/Header/AppHeader.vue       |  4 +-
 src/components/App/Menu/AppMenu.vue           | 16 +++++-
 .../RouteAssets/Stages/ReviewDetails.vue      | 26 +++++++---
 .../components/RouteAssets/SwapDialog.vue     | 51 +++++++++++++++++--
 src/store/routeAssets/types.ts                |  6 +++
 6 files changed, 90 insertions(+), 22 deletions(-)

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 2811e766b..125d64b50 100644
--- a/src/components/App/Menu/AppMenu.vue
+++ b/src/components/App/Menu/AppMenu.vue
@@ -1,5 +1,8 @@
 <template>
-  <s-scrollbar class="app-menu app-sidebar-scrollbar" :class="{ visible, 'app-menu__about': isAboutPageOpened }">
+  <s-scrollbar
+    class="app-menu app-sidebar-scrollbar"
+    :class="{ visible, 'app-menu__about': isAboutPageOpened, 'app-menu__route-assets': isRouteAssetsPage }"
+  >
     <aside class="app-sidebar">
       <slot name="head"></slot>
       <div class="app-sidebar-menu">
@@ -84,6 +87,7 @@ import {
 
 import { lazyComponent } from '@/router';
 import { getter, state } from '@/store/decorators';
+import { AdarPageNames } from '@/modules/ADAR/consts';
 
 @Component({
   components: {
@@ -135,6 +139,10 @@ export default class AppMenu extends Mixins(TranslationMixin) {
   openSoraDownloadDialog(): void {
     this.$emit('open-download-dialog');
   }
+
+  get isRouteAssetsPage(): boolean {
+    return this.$route.name === AdarPageNames.RouteAssets;
+  }
 }
 </script>
 
@@ -298,6 +306,12 @@ export default class AppMenu extends Mixins(TranslationMixin) {
         position: relative;
       }
     }
+
+    &__route-assets {
+      @include tablet {
+        position: relative;
+      }
+    }
   }
 
   &-sidebar {
diff --git a/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue b/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
index 08ee866ff..a19c30128 100644
--- a/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
+++ b/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
@@ -92,7 +92,7 @@
         </div>
       </div>
     </div>
-    <swap-dialog :visible.sync="showSwapDialog"></swap-dialog>
+    <swap-dialog :visible.sync="showSwapDialog" :presetSwapData="presetSwapData"></swap-dialog>
     <select-input-asset-dialog
       :visible.sync="showSelectInputAssetDialog"
       @onInputAssetSelected="onInputAssetSelected"
@@ -102,19 +102,17 @@
 
 <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';
 @Component({
   components: {
     TokenLogo: components.TokenLogo,
@@ -181,6 +179,18 @@ export default class ReviewDetails extends Mixins(mixins.TransactionMixin) {
     });
   }
 
+  get presetSwapData(): PresetSwapData {
+    const isInputAssetXor = this.inputToken.symbol === XOR.symbol;
+    const assetFrom = isInputAssetXor ? VAL : XOR;
+    const assetTo = this.inputToken;
+    const valueTo = this.remainingAmountRequired;
+    return {
+      assetFrom,
+      assetTo,
+      valueTo,
+    };
+  }
+
   get fpBalance(): FPNumber {
     if (!this.getTokenBalance) return FPNumber.ZERO;
 
diff --git a/src/modules/ADAR/components/RouteAssets/SwapDialog.vue b/src/modules/ADAR/components/RouteAssets/SwapDialog.vue
index d506ff54b..ee3e11488 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();
+  }
+
+  @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')
+  onValueToChanged(newVal) {
+    if (newVal <= 0) {
+      this.$emit('update:visible', false);
+    }
+  }
+}
 </script>
 
 <style lang="scss">
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;
+};

From 5c3891203cdcbdc0872e551998f6f904a1692d49 Mon Sep 17 00:00:00 2001
From: Timofey Trepalin <trepalin@soramitsu.co.jp>
Date: Wed, 8 Feb 2023 18:13:21 +0500
Subject: [PATCH 2/5] Changed all issue fix string

---
 src/lang/en.json                              | 25 ++++++++++++++++---
 .../RouteAssets/Stages/ReviewDetails.vue      |  2 +-
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/lang/en.json b/src/lang/en.json
index 0fb7107a1..aef0c0fdd 100644
--- a/src/lang/en.json
+++ b/src/lang/en.json
@@ -1077,12 +1077,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 c7c139e28..f28af298f 100644
--- a/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
+++ b/src/modules/ADAR/components/RouteAssets/Stages/ReviewDetails.vue
@@ -45,7 +45,7 @@
           </div>
           <warning-message
             class="warning-message"
-            :text="noIssues ? 'ALL ISSUES ARE FIXED' : 'insufficient funds'"
+            :text="noIssues ? 'balance is ok' : 'insufficient funds'"
             :isError="!noIssues"
           />
         </div>

From 46a28aea9fff288b7ef10ada19997427c63ed8db Mon Sep 17 00:00:00 2001
From: Timofey Trepalin <trepalin@soramitsu.co.jp>
Date: Wed, 1 Mar 2023 12:58:05 +0500
Subject: [PATCH 3/5] New swap transfer batch

---
 src/App.vue                      |   4 +-
 src/store/routeAssets/actions.ts | 286 ++++++++++++++-----------------
 2 files changed, 127 insertions(+), 163 deletions(-)

diff --git a/src/App.vue b/src/App.vue
index 5586d239f..19f759ff5 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -377,7 +377,7 @@ export default class App extends Mixins(mixins.TransactionMixin, NodeErrorMixin)
     // console.dir(value);
     // console.groupEnd();
 
-    const message = this.getMessage(value, this.shouldBalanceBeHidden);
+    const message = this.getOperationMessage(value, this.shouldBalanceBeHidden);
     const isNewTx = !oldValue || oldValue.id !== value.id;
     const recipients = this.recipients.filter((item) => item.txId === value.id);
 
@@ -390,7 +390,7 @@ export default class App extends Mixins(mixins.TransactionMixin, NodeErrorMixin)
           status: RecipientStatus.FAILED,
         });
       });
-    } else if (value.status === TransactionStatus.InBlock || isNewTx) {
+    } else if (value.status === TransactionStatus.Finalized) {
       if (isNewTx) {
         recipients.forEach((reciever) => {
           this.setRecipientStatus({
diff --git a/src/store/routeAssets/actions.ts b/src/store/routeAssets/actions.ts
index 29ef77557..4e5fb5cf1 100644
--- a/src/store/routeAssets/actions.ts
+++ b/src/store/routeAssets/actions.ts
@@ -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 {
@@ -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,
         },
@@ -413,126 +377,78 @@ 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 {
-      recievers,
-      params: calcTxParams(inputAsset, outputAsset, maxInputAmount, undefined, dexId),
-      options,
+      accountId: item.swapAndSendData.address,
+      targetAmount,
+      assetAddress: item.swapAndSendData.asset.address,
+      recipientId: item.recipient.id,
+      targetAmountNum: Number(item.swapAndSendData.targetAmount),
+      dexId: item.swapAndSendData.dexId,
     };
   });
+  const groupedData = Object.entries(groupBy(newData, 'assetAddress'));
 
   // const formattedToAddress = receiver.slice(0, 2) === 'cn' ? receiver : this.root.formatAddress(receiver);
+  const maxInputAmount = getAssetBalance(inputAsset);
+  const params = calcTxParams(inputAsset, maxInputAmount, undefined, undefined);
+  // console.dir(groupedData);
+  // console.dir(params);
 
-  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,
-                });
+  await withLoading(async () => {
+    try {
+      // const { params, options } = tx;
+      const time = Date.now();
+      await api
+        .submitExtrinsic(
+          (api.api.tx.liquidityProxy as any).swapTransferBatch(groupedData, ...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);
+          groupedData.forEach((recievers) => {
+            recievers[1].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,
+          groupedData.forEach((recievers) => {
+            recievers[1].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);
+      groupedData.forEach((recievers) => {
+        recievers[1].forEach((receiver) => {
+          commit.setRecipientStatus({
+            id: receiver.recipientId,
+            status: RecipientStatus.FAILED,
+          });
         });
       });
-      throw new Error(err);
-    });
+    }
+  });
 }
 
 async function getLastTransaction(time: number): Promise<any> {
@@ -559,21 +475,20 @@ 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
 ) {
   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,
+      asset.address,
+      // assetTo.address,
       amount,
       liquiditySources,
       liquiditySource === LiquiditySourceTypes.Default ? 'Disabled' : 'AllowSelected',
@@ -581,4 +496,53 @@ function calcTxParams(
   };
 }
 
+function getAmountAndDexId(context: any, assetFrom: any, assetTo: any, usd: any) {
+  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 =
+    Number(usd) / Number(FPNumber.fromCodecValue(rootState.wallet.account.fiatPriceObject[assetTo.address], 18));
+  console.log(`tokenEquivalent - ${tokenEquivalent}`);
+  console.log(`usd - ${usd}`);
+  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];
+  console.log(`amount - ${FPNumber.fromCodecValue(amount).toNumber()}`);
+  return { amountFrom: amount, amountTo: tokenEquivalent, bestDexId, allDexes: results };
+}
+
 export default actions;

From 6e3ee8b5471040a147ab110188f65a4b20dfeda3 Mon Sep 17 00:00:00 2001
From: Timofey Trepalin <trepalin@soramitsu.co.jp>
Date: Thu, 2 Mar 2023 14:34:03 +0500
Subject: [PATCH 4/5] Delete console log

---
 src/store/routeAssets/actions.ts | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/store/routeAssets/actions.ts b/src/store/routeAssets/actions.ts
index 4e5fb5cf1..00a90ab42 100644
--- a/src/store/routeAssets/actions.ts
+++ b/src/store/routeAssets/actions.ts
@@ -396,9 +396,6 @@ async function executeBatchSwapAndSend(context, data: Array<any>): Promise<any>
   // const formattedToAddress = receiver.slice(0, 2) === 'cn' ? receiver : this.root.formatAddress(receiver);
   const maxInputAmount = getAssetBalance(inputAsset);
   const params = calcTxParams(inputAsset, maxInputAmount, undefined, undefined);
-  // console.dir(groupedData);
-  // console.dir(params);
-
   await withLoading(async () => {
     try {
       // const { params, options } = tx;
@@ -503,8 +500,6 @@ function getAmountAndDexId(context: any, assetFrom: any, assetTo: any, usd: any)
   const { paths, payload, liquiditySources, dexQuoteData } = subscription;
   const tokenEquivalent =
     Number(usd) / Number(FPNumber.fromCodecValue(rootState.wallet.account.fiatPriceObject[assetTo.address], 18));
-  console.log(`tokenEquivalent - ${tokenEquivalent}`);
-  console.log(`usd - ${usd}`);
   const dexes = api.dex.dexList;
   const results = dexes.reduce<{ [dexId: number]: SwapResult }>((buffer, { dexId }) => {
     const swapResult = api.swap.getResult(
@@ -541,7 +536,6 @@ function getAmountAndDexId(context: any, assetFrom: any, assetTo: any, usd: any)
   }
 
   const { amount, amountWithoutImpact, fee, rewards } = results[bestDexId];
-  console.log(`amount - ${FPNumber.fromCodecValue(amount).toNumber()}`);
   return { amountFrom: amount, amountTo: tokenEquivalent, bestDexId, allDexes: results };
 }
 

From 802e2b8039e0e6557290fc422bd9e43abfd16b25 Mon Sep 17 00:00:00 2001
From: Timofey Trepalin <trepalin@soramitsu.co.jp>
Date: Thu, 2 Mar 2023 15:14:33 +0500
Subject: [PATCH 5/5] Added types in routeAsset/action

---
 src/store/routeAssets/actions.ts | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/store/routeAssets/actions.ts b/src/store/routeAssets/actions.ts
index 00a90ab42..da37de003 100644
--- a/src/store/routeAssets/actions.ts
+++ b/src/store/routeAssets/actions.ts
@@ -13,7 +13,7 @@ import type { DexQuoteData } from '@/store/swap/types';
 import { DexId } from '@sora-substrate/util/build/dex/consts';
 import type { QuotePayload, SwapResult } from '@sora-substrate/liquidity-proxy/build/types';
 import { LiquiditySourceTypes } from '@sora-substrate/liquidity-proxy/build/consts';
-import { findLast, groupBy, sumBy } from 'lodash';
+import { findLast, groupBy } from 'lodash';
 import { NumberLike } from '@sora-substrate/math';
 import { Messages } from '@sora-substrate/util/build/logger';
 import { assert } from '@polkadot/util';
@@ -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
@@ -270,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));
@@ -334,9 +334,6 @@ function getTransferParams(context, inputAsset, recipient) {
       };
     } catch (error: any) {
       throw new Error(error);
-      return {
-        recipient,
-      };
     }
   }
 }
@@ -377,7 +374,7 @@ function getTransferParams(context, inputAsset, recipient) {
 // ______________________________________________________________________
 
 async function executeBatchSwapAndSend(context, data: Array<any>): Promise<any> {
-  const { commit, getters, rootCommit, rootState } = routeAssetsActionContext(context);
+  const { commit, getters, rootCommit } = routeAssetsActionContext(context);
   const inputAsset = getters.inputToken;
   const newData = data.map((item) => {
     const decimals = item.swapAndSendData.asset.decimals;
@@ -493,7 +490,7 @@ function calcTxParams(
   };
 }
 
-function getAmountAndDexId(context: any, assetFrom: any, assetTo: any, usd: any) {
+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;