Merge pull request paraswap#95 from paraswap/fix/dex-key-special

Handle special dexkey for payload encoding
dystopia-exchange · Apr 21, 2022 · e0d6b44 · e0d6b44
2 parents f2a7501 + 6c84d1a
commit e0d6b44
Show file tree

Hide file tree

Showing 8 changed files with 50 additions and 49 deletions.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@paraswap/dex-lib",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": "https://github.com/paraswap/paraswap-dex-lib",

diff --git a/src/dex/index.ts b/src/dex/index.ts
@@ -159,20 +159,22 @@ export class DexAdapterService {
             this.dexHelper,
           );
 
-          const sellAdapters = (
+          const sellAdaptersDex = (
             this.dexInstances[_key] as IDex<any, any, any>
           ).getAdapters(SwapSide.SELL);
-          if (sellAdapters)
-            this.sellAdapters[_key] = sellAdapters.map(({ name, index }) => ({
-              adapter: AdapterNameAddressMap[network][name],
-              index,
-            }));
+          if (sellAdaptersDex)
+            this.sellAdapters[_key] = sellAdaptersDex.map(
+              ({ name, index }) => ({
+                adapter: AdapterNameAddressMap[network][name],
+                index,
+              }),
+            );
 
-          const buyAdapters = (
+          const buyAdaptersDex = (
             this.dexInstances[_key] as IDex<any, any, any>
           ).getAdapters(SwapSide.BUY);
-          if (buyAdapters)
-            this.buyAdapters[_key] = buyAdapters.map(({ name, index }) => ({
+          if (buyAdaptersDex)
+            this.buyAdapters[_key] = buyAdaptersDex.map(({ name, index }) => ({
               adapter: AdapterNameAddressMap[network][name],
               index,
             }));
@@ -197,17 +199,7 @@ export class DexAdapterService {
   }
 
   getTxBuilderDexByKey(dexKey: string): IDexTxBuilder<any, any> {
-    let _dexKey = dexKey.toLowerCase();
-
-    if (/^paraswappool(.*)/i.test(_dexKey)) _dexKey = 'zerox';
-
-    if ('uniswapforkoptimized' === _dexKey) {
-      if (!this.uniswapV2Alias)
-        throw new Error(
-          `${dexKey} dex is not supported for network(${this.network})!`,
-        );
-      _dexKey = this.uniswapV2Alias;
-    }
+    let _dexKey = this.getDexKeySpecial(dexKey);
 
     if (!this.dexInstances[_dexKey]) {
       const DexAdapter = this.dexToKeyMap[_dexKey];
@@ -245,4 +237,24 @@ export class DexAdapterService {
   getAllDexAdapters(side: SwapSide = SwapSide.SELL) {
     return side === SwapSide.SELL ? this.sellAdapters : this.buyAdapters;
   }
+
+  getDexKeySpecial(dexKey: string) {
+    dexKey = dexKey.toLowerCase();
+    if (/^paraswappool(.*)/i.test(dexKey)) return 'zerox';
+    else if ('uniswapforkoptimized' === dexKey) {
+      if (!this.uniswapV2Alias)
+        throw new Error(
+          `${dexKey} dex is not supported for network(${this.network})!`,
+        );
+      return this.uniswapV2Alias;
+    }
+    return dexKey;
+  }
+
+  getAdapter(dexKey: string, side: SwapSide) {
+    const specialDexKey = this.getDexKeySpecial(dexKey);
+    return side === SwapSide.SELL
+      ? this.sellAdapters[specialDexKey]
+      : this.buyAdapters[specialDexKey];
+  }
 }
diff --git a/src/router/buy.ts b/src/router/buy.ts
@@ -19,8 +19,8 @@ export class Buy extends PayloadEncoder implements IRouter<BuyParam> {
   paraswapInterface: Interface;
   contractMethodName: string;
 
-  constructor(dexAdapterService: DexAdapterService, adapters: Adapters) {
-    super(dexAdapterService, adapters);
+  constructor(dexAdapterService: DexAdapterService) {
+    super(dexAdapterService);
     this.paraswapInterface = new Interface(IParaswapABI);
     this.contractMethodName = 'buy';
   }

diff --git a/src/router/index.ts b/src/router/index.ts
@@ -16,16 +16,10 @@ export class RouterService {
   directSwapRouter: DirectSwap<any>;
 
   constructor(private dexAdapterService: DexAdapterService) {
-    const adapters = dexAdapterService.getAllDexAdapters(SwapSide.SELL);
-    const buyAdapters = dexAdapterService.getAllDexAdapters(SwapSide.BUY);
-
     this.hybridRouterMap = this.hybridRouters.reduce<{
       [contractMethod: string]: IRouter<any>;
     }>((acc, Router) => {
-      const router = new Router(
-        this.dexAdapterService,
-        Router.isBuy ? buyAdapters : adapters,
-      );
+      const router = new Router(this.dexAdapterService);
       acc[router.getContractMethodName().toLowerCase()] = router;
       return acc;
     }, {});

diff --git a/src/router/megaswap.ts b/src/router/megaswap.ts
@@ -19,8 +19,8 @@ export class MegaSwap extends PayloadEncoder implements IRouter<MegaSwapParam> {
   paraswapInterface: Interface;
   contractMethodName: string;
 
-  constructor(dexAdapterService: DexAdapterService, adapters: Adapters) {
-    super(dexAdapterService, adapters);
+  constructor(dexAdapterService: DexAdapterService) {
+    super(dexAdapterService);
     this.paraswapInterface = new Interface(IParaswapABI);
     this.contractMethodName = 'megaSwap';
   }

diff --git a/src/router/multiswap.ts b/src/router/multiswap.ts
@@ -22,8 +22,8 @@ export class MultiSwap
   paraswapInterface: Interface;
   contractMethodName: string;
 
-  constructor(dexAdapterService: DexAdapterService, adapters: Adapters) {
-    super(dexAdapterService, adapters);
+  constructor(dexAdapterService: DexAdapterService) {
+    super(dexAdapterService);
     this.paraswapInterface = new Interface(IParaswapABI);
     this.contractMethodName = 'multiSwap';
   }

diff --git a/src/router/payload-encoder.ts b/src/router/payload-encoder.ts
@@ -36,10 +36,7 @@ export function encodeFeePercent(
 // This class can be used commonly by all the router
 // that will use the adapters.
 export class PayloadEncoder {
-  constructor(
-    protected dexAdapterService: DexAdapterService,
-    protected adapters: Adapters,
-  ) {}
+  constructor(protected dexAdapterService: DexAdapterService) {}
   // Should have function for optimally choosing the Adapters
   getContractPathsWithNetworkFee(swaps: OptimalSwap[]): {
     paths: ContractPath[];
@@ -193,7 +190,7 @@ export class PayloadEncoder {
 
     const adapterPoints: { [adapter: string]: number } = {};
     swapExchanges.forEach(se => {
-      const adapters = this.adapters[se.exchange.toLowerCase()];
+      const adapters = this.dexAdapterService.getAdapter(se.exchange, side);
       if (!adapters.length)
         throw new Error(`No adapter found for ${se.exchange}`);
       adapters.forEach(a => {
@@ -213,12 +210,11 @@ export class PayloadEncoder {
     const leftSwapExchange: OptimalSwapExchange<any>[] = [];
 
     swapExchanges.forEach(se => {
-      const exchangeKey = se.exchange.toLowerCase();
-      const adapterConfig = this.adapters[exchangeKey].find(
-        ({ adapter }) => adapter.toLowerCase() === bestAdapter,
-      );
+      const adapterConfig = this.dexAdapterService
+        .getAdapter(se.exchange, side)
+        .find(({ adapter }) => adapter.toLowerCase() === bestAdapter);
       if (adapterConfig) {
-        optimalAdapters[exchangeKey] = [
+        optimalAdapters[se.exchange.toLowerCase()] = [
           adapterConfig.adapter,
           adapterConfig.index,
         ];

diff --git a/src/router/simpleswap.ts b/src/router/simpleswap.ts
@@ -31,7 +31,6 @@ abstract class SimpleRouter implements IRouter<SimpleSwapParam> {
 
   constructor(
     protected dexAdapterService: DexAdapterService,
-    adapters: Adapters,
     protected side: SwapSide,
 
     // prepare mapping: network -> wrapped exchange key
@@ -261,14 +260,14 @@ abstract class SimpleRouter implements IRouter<SimpleSwapParam> {
 
 export class SimpleSwap extends SimpleRouter {
   static isBuy = false;
-  constructor(dexAdapterService: DexAdapterService, adapters: Adapters) {
-    super(dexAdapterService, adapters, SwapSide.SELL);
+  constructor(dexAdapterService: DexAdapterService) {
+    super(dexAdapterService, SwapSide.SELL);
   }
 }
 
 export class SimpleBuy extends SimpleRouter {
   static isBuy = true;
-  constructor(dexAdapterService: DexAdapterService, adapters: Adapters) {
-    super(dexAdapterService, adapters, SwapSide.BUY);
+  constructor(dexAdapterService: DexAdapterService) {
+    super(dexAdapterService, SwapSide.BUY);
   }
 }