@paraswap/dex-lib 3.8.1 → 3.8.3-integral-dex

package/src/config.ts

@@ -228,7 +228,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     adapterAddresses: {
       AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
       AvalancheAdapter02: '0xA10c9a84E72d9DfF424Fe2284B6460784bed407E',
-      AvalancheBuyAdapter: '0xaB38a72de187Cd5d6D9bACD6D13D090E841EC330',
+      AvalancheBuyAdapter: '0x654dE10890f8B2C5bF54E50Af169a7E93165C416',
     },
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',

package/src/dex/OneInchLp.ts

@@ -0,0 +1,84 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { NULL_ADDRESS, SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import { IDexTxBuilder } from './idex';
+import { SimpleExchange } from './simple-exchange';
+import OneInchLpABI from '../abi/OneInchLp.json';
+import { isETHAddress } from '../utils';
+import Web3 from 'web3';
+import { IDexHelper } from '../dex-helper';
+
+export type OneInchLpData = {
+  exchange: string; // _DOUBLE_CHECK_
+};
+type OneInchLpParam = [
+  src: string,
+  dst: string,
+  amount: string,
+  minReturn: string,
+  referral: string,
+];
+enum OneInchLpFunctions {
+  swap = 'swap',
+}
+
+export class OneInchLp
+  extends SimpleExchange
+  implements IDexTxBuilder<OneInchLpData, OneInchLpParam>
+{
+  static dexKeys = ['oneinchlp'];
+  exchangeRouterInterface: Interface;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'oneinchlp');
+    this.exchangeRouterInterface = new Interface(
+      OneInchLpABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OneInchLpData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.exchange,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OneInchLpData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = OneInchLpFunctions.swap;
+    const swapFunctionParams: OneInchLpParam = [
+      isETHAddress(srcToken) ? NULL_ADDRESS : srcToken,
+      isETHAddress(destToken) ? NULL_ADDRESS : destToken,
+      srcAmount,
+      destAmount,
+      NULL_ADDRESS,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.exchange,
+    );
+  }
+}

package/src/dex/bProtocol/bProtocol-e2e.test.ts

@@ -0,0 +1,93 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const dexKey = 'bprotocol';
+
+// ! LIQUIDITY ISSUES
+
+const testForNetwork = (
+  network: Network,
+  swapMap: Map<SwapSide, ContractMethod[]>,
+) => {
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const nativeSymbol = NativeTokenSymbols[network];
+
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  const tokensToTest = [
+    [
+      {
+        symbol: 'LUSD',
+        amount: '100000000000000000000',
+      },
+      {
+        symbol: 'ETH',
+        amount: '35360886801038522',
+      },
+    ],
+  ];
+
+  swapMap.forEach((contractMethods, side) =>
+    contractMethods.forEach((contractMethod: string) => {
+      tokensToTest.forEach(pair => {
+        describe(`${contractMethod}`, () => {
+          it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
+            await testE2E(
+              tokens[pair[0].symbol],
+              tokens[pair[1].symbol],
+              holders[pair[0].symbol],
+              side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+
+          it(`${nativeSymbol} -> ${pair[0].symbol}`, async () => {
+            await testE2E(
+              tokens[nativeSymbol],
+              tokens[pair[0].symbol],
+              holders[nativeSymbol],
+              side === SwapSide.SELL ? '1000000000000000000' : pair[0].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    }),
+  );
+};
+
+// Ensure you have the E2E_ENDPOINT_URL env variable set.
+
+describe('bProtocol E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

package/src/dex/bProtocol/bProtocol.ts

@@ -0,0 +1,108 @@
+import { Interface, JsonFragment } 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 BProtocolABI from '../../abi/BProtocol.json';
+import { IDexHelper } from '../../dex-helper';
+import { BProtocolData, BProtocolFunctions, BProtocolParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
+
+export class BProtocol
+  extends SimpleExchange
+  implements IDexTxBuilder<BProtocolData, BProtocolParam>
+{
+  static dexKeys = ['bprotocol'];
+  exchangeRouterInterface: Interface;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'bprotocol');
+    this.exchangeRouterInterface = new Interface(
+      BProtocolABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: BProtocolData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.exchange,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: BProtocolData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = BProtocolFunctions.swap;
+    const swapFunctionParams: BProtocolParam = [
+      srcAmount,
+      destAmount,
+      this.augustusAddress,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.exchange,
+    );
+  }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: BProtocolData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = BProtocolFunctions.swap;
+    const swapFunctionParams: BProtocolParam = [
+      srcAmount,
+      destAmount,
+      recipient,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.exchange,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+            )
+          : undefined,
+    };
+  }
+}

package/src/dex/bProtocol/types.ts

@@ -0,0 +1,13 @@
+export type BProtocolData = {
+  exchange: string;
+};
+
+export type BProtocolParam = [
+  lusdAmount: string,
+  minEthReturn: string,
+  dest: string,
+];
+
+export enum BProtocolFunctions {
+  swap = 'swap',
+}

package/src/dex/curve-v1-factory/config.ts

@@ -25,7 +25,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x16C6521Dff6baB339122a0FE25a9116693265353', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 5 * 1000,
       disabledPools: new Set([
         '0x28B0Cf1baFB707F2c6826d10caf6DD901a6540C5', // It is rug pool token
@@ -222,8 +221,11 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           address: '0x722272D36ef0Da72FF51c5A65Db7b870E2e8D4ee',
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
+        {
+          address: '0x1764ee18e8B3ccA4787249Ceb249356192594585', // factory stable ng
+          isStableNg: true,
+        },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([
         '0x666Dc3b4baBfd063FaF965BD020024AF0dC51B64',
@@ -335,7 +337,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -456,7 +457,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       // FIX: This must be removed when we go for full CurveV1 event based support
       disabledPools: new Set(['0x16a7da911a4dd1d83f3ff066fe28f3c792c50d90']),
@@ -543,7 +543,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x2191718CD32d02B8E60BAdFFeA33E4B5DD9A0A0D', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -675,7 +674,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -788,7 +786,6 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
           maxPlainCoins: FACTORY_MAX_PLAIN_COINS,
         },
       ],
-      router: '0x4f37A9d177470499A2dD084621020b023fcffc1F', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -827,10 +824,13 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 3,
       },
     ],
-    [SwapSide.BUY]: [
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [
+      // use for beltfi (deprecated)
       {
-        name: 'BuyAdapter02',
-        index: 5,
+        name: 'BscAdapter01',
+        index: 2,
       },
     ],
   },
@@ -841,12 +841,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 3,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'PolygonBuyAdapter',
-        index: 10,
-      },
-    ],
   },
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [
@@ -855,12 +849,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 5,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'AvalancheBuyAdapter',
-        index: 9,
-      },
-    ],
   },
   [Network.FANTOM]: {
     [SwapSide.SELL]: [
@@ -869,12 +857,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 3,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'FantomBuyAdapter',
-        index: 6,
-      },
-    ],
   },
   [Network.ARBITRUM]: {
     [SwapSide.SELL]: [
@@ -883,12 +865,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 6,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'ArbitrumBuyAdapter',
-        index: 12,
-      },
-    ],
   },
   [Network.OPTIMISM]: {
     [SwapSide.SELL]: [
@@ -897,12 +873,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 5,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'OptimismBuyAdapter',
-        index: 8,
-      },
-    ],
   },
   [Network.BASE]: {
     [SwapSide.SELL]: [
@@ -911,12 +881,6 @@ export const Adapters: Record<number, AdapterMappings> = {
         index: 3,
       },
     ],
-    [SwapSide.BUY]: [
-      {
-        name: 'BaseBuyAdapter',
-        index: 9,
-      },
-    ],
   },
 };
 
@@ -982,7 +946,6 @@ export const configAddressesNormalizer = (
               address: e.address.toLowerCase(),
             }))
           : _config.factories,
-        router: _config.router,
         stateUpdatePeriodMs: _config.stateUpdatePeriodMs,
         factoryPoolImplementations,
         customPools,

package/src/dex/curve-v1-factory/curve-v1-factory-e2e.test.ts

@@ -10,14 +10,13 @@ dotenv.config();
 
 export function testForNetwork(
   network: Network,
-  dexKey: string | string[],
+  dexKey: string,
   tokenASymbol: string,
   tokenBSymbol: string,
   tokenAAmount: string,
   tokenBAmount: string,
   sideToContractMethods: Map<SwapSide, ContractMethod[]> = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]),
 ) {
   const provider = new StaticJsonRpcProvider(
@@ -27,6 +26,8 @@ export function testForNetwork(
   const tokens = Tokens[network];
   const holders = Holders[network];
 
+  // const sideToContractMethods = ;
+
   describe(`${network}`, () => {
     sideToContractMethods.forEach((contractMethods, side) =>
       describe(`${side}`, () => {
@@ -61,11 +62,6 @@ export function testForNetwork(
                 contractMethod,
                 network,
                 provider,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                5000,
               );
             });
           });
@@ -76,78 +72,25 @@ export function testForNetwork(
 }
 
 describe('CurveV1Factory E2E', () => {
-  const dexKey = ['CurveV1Factory', 'CurveV1StableNg'];
+  const dexKey = 'CurveV1Factory';
 
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
-    describe('USDT -> USDD', () => {
-      const tokenASymbol: string = 'USDT';
-      const tokenBSymbol: string = 'USDD';
-
-      const tokenAAmount: string = '100000000';
-      const tokenBAmount: string = '111000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-      );
-    });
-
-    describe('GHO -> USDC', () => {
-      const tokenASymbol: string = 'GHO';
-      const tokenBSymbol: string = 'USDC';
-
-      const tokenAAmount: string = '1000000000000000000';
-      const tokenBAmount: string = '100000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-      );
-    });
-
-    describe('GHO -> crvUSD', () => {
-      const tokenASymbol: string = 'GHO';
-      const tokenBSymbol: string = 'crvUSD';
-
-      const tokenAAmount: string = '1000000000000000000';
-      const tokenBAmount: string = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-      );
-    });
-
-    describe('GHO -> USDT', () => {
-      const tokenASymbol: string = 'GHO';
-      const tokenBSymbol: string = 'USDT';
+    const tokenASymbol: string = 'USDT';
+    const tokenBSymbol: string = 'USDD';
 
-      const tokenAAmount: string = '10000000000000000000';
-      const tokenBAmount: string = '1000000';
+    const tokenAAmount: string = '100000000';
+    const tokenBAmount: string = '111000000000000000000';
 
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-      );
-    });
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
   });
   describe('Mainnet Native', () => {
     const network = Network.MAINNET;
@@ -379,7 +322,6 @@ describe('CurveV1Factory E2E', () => {
         SwapSide.SELL,
         [ContractMethod.swapExactAmountIn, ContractMethod.directCurveV1Swap],
       ],
-      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
       // [
       //   SwapSide.SELL,
       //   [
@@ -407,23 +349,5 @@ describe('CurveV1Factory E2E', () => {
         sideToContractMethods,
       );
     });
-
-    describe('USDM -> crvUSD', () => {
-      const tokenASymbol: string = 'USDM';
-      const tokenBSymbol: string = 'crvUSD';
-
-      const tokenAAmount: string = '1000000000000000000';
-      const tokenBAmount: string = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-        sideToContractMethods,
-      );
-    });
   });
 });