@paraswap/dex-lib 3.4.2-balancer-v2-single-swap.0 → 3.4.2

package/src/dex/stable-pool/stable-pool.ts

@@ -1,129 +1,129 @@
-import { Interface } from '@ethersproject/abi';
-import { SwapSide } from '../../constants';
-import {
-  AdapterExchangeParam,
-  Address,
-  DexExchangeParam,
-  NumberAsString,
-  SimpleExchangeParam,
-} from '../../types';
-import { IDexTxBuilder } from '../idex';
-import { SimpleExchange } from '../simple-exchange';
-import StablePoolABI from '../../abi/StablePool.json';
-import { IDexHelper } from '../../dex-helper';
-import { StablePoolFunctions, StablePoolData, StablePoolParam } from './types';
-import { extractReturnAmountPosition } from '../../executor/utils';
-
-export class StablePool
-  extends SimpleExchange
-  implements IDexTxBuilder<StablePoolData, StablePoolParam>
-{
-  static dexKeys = ['nerve', 'ironv2', 'snowball', 'axial'];
-  exchangeRouterInterface: Interface;
-  minConversionRate = '1';
-
-  constructor(dexHelper: IDexHelper) {
-    super(dexHelper, 'stablePool');
-    this.exchangeRouterInterface = new Interface(StablePoolABI);
-  }
-
-  getAdapterParam(
-    _srcToken: string,
-    _destToken: string,
-    _srcAmount: string,
-    _destAmount: string,
-    data: StablePoolData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { i, j, deadline } = data;
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          i: 'int128',
-          j: 'int128',
-          deadline: 'uint256',
-        },
-      },
-      { i, j, deadline },
-    );
-    return {
-      targetExchange: data.exchange,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: StablePoolData,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { exchange, i, j, deadline } = data;
-    const swapFunctionParams: StablePoolParam = [
-      i,
-      j,
-      srcAmount,
-      this.minConversionRate,
-      deadline,
-    ];
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      StablePoolFunctions.swap,
-      swapFunctionParams,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      exchange,
-    );
-  }
-
-  getDexParam(
-    _srcToken: Address,
-    _destToken: Address,
-    srcAmount: NumberAsString,
-    _destAmount: NumberAsString,
-    _recipient: Address,
-    data: StablePoolData,
-    side: SwapSide,
-  ): DexExchangeParam {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { exchange, i, j, deadline } = data;
-    const swapFunctionParams: StablePoolParam = [
-      i,
-      j,
-      srcAmount,
-      this.minConversionRate,
-      deadline,
-    ];
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      StablePoolFunctions.swap,
-      swapFunctionParams,
-    );
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: false,
-      exchangeData: swapData,
-      targetExchange: exchange,
-      returnAmountPos:
-        side === SwapSide.SELL
-          ? extractReturnAmountPosition(
-              this.exchangeRouterInterface,
-              StablePoolFunctions.swap,
-            )
-          : undefined,
-    };
-  }
-}
+import { Interface } from '@ethersproject/abi';
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import StablePoolABI from '../../abi/StablePool.json';
+import { IDexHelper } from '../../dex-helper';
+import { StablePoolFunctions, StablePoolData, StablePoolParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
+
+export class StablePool
+  extends SimpleExchange
+  implements IDexTxBuilder<StablePoolData, StablePoolParam>
+{
+  static dexKeys = ['nerve', 'ironv2', 'snowball', 'axial'];
+  exchangeRouterInterface: Interface;
+  minConversionRate = '1';
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'stablePool');
+    this.exchangeRouterInterface = new Interface(StablePoolABI);
+  }
+
+  getAdapterParam(
+    _srcToken: string,
+    _destToken: string,
+    _srcAmount: string,
+    _destAmount: string,
+    data: StablePoolData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { i, j, deadline } = data;
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          i: 'int128',
+          j: 'int128',
+          deadline: 'uint256',
+        },
+      },
+      { i, j, deadline },
+    );
+    return {
+      targetExchange: data.exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: StablePoolData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, deadline } = data;
+    const swapFunctionParams: StablePoolParam = [
+      i,
+      j,
+      srcAmount,
+      this.minConversionRate,
+      deadline,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      StablePoolFunctions.swap,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    data: StablePoolData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, deadline } = data;
+    const swapFunctionParams: StablePoolParam = [
+      i,
+      j,
+      srcAmount,
+      this.minConversionRate,
+      deadline,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      StablePoolFunctions.swap,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              StablePoolFunctions.swap,
+            )
+          : undefined,
+    };
+  }
+}

package/src/dex/swaap-v2/config.ts

@@ -7,6 +7,9 @@ export const SwaapV2Config: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {},
     [Network.POLYGON]: {},
     [Network.ARBITRUM]: {},
+    [Network.BASE]: {},
+    [Network.BSC]: {},
+    [Network.OPTIMISM]: {},
   },
 };
 
@@ -23,4 +26,16 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 6 }],
     [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 8 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter02', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 8 }],
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 11 }],
+    [SwapSide.BUY]: [{ name: 'BscBuyAdapter', index: 9 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter02', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 7 }],
+  },
 };

package/src/dex/swaap-v2/swaap-v2-e2e.test.ts

@@ -60,18 +60,6 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
       ],
-      [
-        {
-          name: 'USDT',
-          sellAmount: '45410357',
-          buyAmount: '100000000',
-        },
-        {
-          name: 'USDC',
-          sellAmount: '100000000',
-          buyAmount: '100000000',
-        },
-      ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -138,7 +126,7 @@ describe('SwaapV2 E2E', () => {
     const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
       [
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '45410357',
           buyAmount: '1000000000000000000',
         },
@@ -155,7 +143,7 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '100000000',
           buyAmount: '150000000000000000000',
         },
@@ -167,7 +155,7 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '100000000',
           buyAmount: '150000000000000000000',
         },
@@ -243,9 +231,237 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '1000000000000000000',
         },
         {
-          name: 'DAI',
+          name: 'USDC',
+          sellAmount: '1000000',
+          buyAmount: '1000000',
+        },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  tokens[pair[0].name],
+                  tokens[pair[1].name],
+                  holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('Base', () => {
+    const network = Network.BASE;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'AERO',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000000000000000',
+        },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  tokens[pair[0].name],
+                  tokens[pair[1].name],
+                  holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('BSC', () => {
+    const network = Network.BSC;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'WBNB',
           sellAmount: '1000000000000000000',
-          buyAmount: '10000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  tokens[pair[0].name],
+                  tokens[pair[1].name],
+                  holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('Optimism', () => {
+    const network = Network.OPTIMISM;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'WETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '45410357',
+          buyAmount: '1000000000000000000',
         },
       ],
     ];

package/src/dex/swaap-v2/swaap-v2-integration.test.ts

@@ -72,7 +72,7 @@ describe('Swaap V2', function () {
     const tokens = Tokens[network];
 
     const srcTokenSymbol = 'WETH';
-    const destTokenSymbol = 'USDC';
+    const destTokenSymbol = 'USDCe';
 
     const amountsForSell = [
       0n,