@paraswap/dex-lib 2.45.0 → 3.0.0

package/tests/utils-e2e.ts

@@ -16,6 +16,7 @@ import {
   MAX_UINT,
   Network,
   ContractMethod,
+  NULL_ADDRESS,
 } from '../src/constants';
 import {
   OptimalRate,
@@ -28,14 +29,32 @@ import {
 import Erc20ABI from '../src/abi/erc20.json';
 import AugustusABI from '../src/abi/augustus.json';
 import { generateConfig } from '../src/config';
-import { DummyDexHelper, DummyLimitOrderProvider } from '../src/dex-helper';
-import { constructSimpleSDK, SimpleFetchSDK } from '@paraswap/sdk';
+import {
+  DummyDexHelper,
+  DummyLimitOrderProvider,
+  IDexHelper,
+} from '../src/dex-helper';
+import {
+  AddressOrSymbol,
+  constructSimpleSDK,
+  SimpleFetchSDK,
+} from '@paraswap/sdk';
 import axios from 'axios';
 import { SmartToken, StateOverrides } from './smart-tokens';
-import { GIFTER_ADDRESS } from './constants-e2e';
+import {
+  GIFTER_ADDRESS,
+  Holders,
+  NativeTokenSymbols,
+  Tokens,
+  WrappedNativeTokenSymbols,
+} from './constants-e2e';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateDeployBytecode, sleep } from './utils';
 import { assert } from 'ts-essentials';
 import * as util from 'util';
+import { GenericSwapTransactionBuilder } from '../src/generic-swap-transaction-builder';
+import { DexAdapterService, PricingHelper } from '../src';
+import { v4 as uuid } from 'uuid';
 
 export const testingEndpoint = process.env.E2E_TEST_ENDPOINT;
 
@@ -92,13 +111,41 @@ const MULTISIG: { [nid: number]: string } = {
 
 class APIParaswapSDK implements IParaSwapSDK {
   paraSwap: SimpleFetchSDK;
-
-  constructor(protected network: number, protected dexKey: string) {
+  dexKeys: string[];
+  dexHelper: IDexHelper;
+  pricingHelper: PricingHelper;
+  transactionBuilder: GenericSwapTransactionBuilder;
+  dexAdapterService: DexAdapterService;
+
+  constructor(
+    protected network: number,
+    dexKeys: string | string[],
+    rpcUrl: string,
+  ) {
+    this.dexKeys = Array.isArray(dexKeys) ? dexKeys : [dexKeys];
     this.paraSwap = constructSimpleSDK({
       chainId: network,
       axios,
       apiURL: testingEndpoint,
     });
+    this.dexHelper = new DummyDexHelper(this.network, rpcUrl);
+
+    this.dexAdapterService = new DexAdapterService(
+      this.dexHelper,
+      this.network,
+    );
+    this.transactionBuilder = new GenericSwapTransactionBuilder(
+      this.dexAdapterService,
+    );
+    this.pricingHelper = new PricingHelper(
+      this.dexAdapterService,
+      this.dexHelper.getLogger,
+    );
+  }
+
+  async initializePricing() {
+    const blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
+    await this.pricingHelper.initialize(blockNumber, this.dexKeys);
   }
 
   async getPrices(
@@ -106,25 +153,51 @@ class APIParaswapSDK implements IParaSwapSDK {
     to: Token,
     amount: bigint,
     side: SwapSide,
-    contractMethod: ContractMethod,
-    _poolIdentifiers?: string[],
+    // contractMethod: ContractMethod,
+    contractMethod: any,
+    _poolIdentifiers?: { [key: string]: string[] | null } | null,
+    transferFees?: TransferFeeParams,
+    forceRoute?: AddressOrSymbol[],
   ): Promise<OptimalRate> {
     if (_poolIdentifiers)
       throw new Error('PoolIdentifiers is not supported by the API');
 
-    const priceRoute = await this.paraSwap.swap.getRate({
-      srcToken: from.address,
-      destToken: to.address,
-      side,
-      amount: amount.toString(),
-      options: {
-        includeDEXS: [this.dexKey],
-        includeContractMethods: [contractMethod],
-        partner: 'any',
-      },
-      srcDecimals: from.decimals,
-      destDecimals: to.decimals,
-    });
+    let priceRoute;
+    if (forceRoute && forceRoute.length > 0) {
+      const options = {
+        route: forceRoute,
+        amount: amount.toString(),
+        side,
+        srcDecimals: from.decimals,
+        destDecimals: to.decimals,
+        options: {
+          includeDEXS: this.dexKeys,
+          includeContractMethods: [contractMethod],
+          partner: 'any',
+          maxImpact: 100,
+        },
+        ...transferFees,
+      };
+      priceRoute = await this.paraSwap.swap.getRateByRoute(options);
+    } else {
+      const options = {
+        srcToken: from.address,
+        destToken: to.address,
+        side,
+        amount: amount.toString(),
+        options: {
+          includeDEXS: this.dexKeys,
+          includeContractMethods: [contractMethod],
+          partner: 'any',
+          maxImpact: 100,
+        },
+        ...transferFees,
+        srcDecimals: from.decimals,
+        destDecimals: to.decimals,
+      };
+      priceRoute = await this.paraSwap.swap.getRate(options);
+    }
+
     return priceRoute as OptimalRate;
   }
 
@@ -134,32 +207,66 @@ class APIParaswapSDK implements IParaSwapSDK {
     userAddress: Address,
   ): Promise<TxObject> {
     const minMaxAmount = _minMaxAmount.toString();
-    const swapParams = await this.paraSwap.swap.buildTx(
-      {
-        srcToken: priceRoute.srcToken,
-        srcDecimals: priceRoute.srcDecimals,
-        destDecimals: priceRoute.destDecimals,
-        destToken: priceRoute.destToken,
-        srcAmount:
-          priceRoute.side === SwapSide.SELL
-            ? priceRoute.srcAmount
-            : minMaxAmount,
-        destAmount:
-          priceRoute.side === SwapSide.SELL
-            ? minMaxAmount
-            : priceRoute.destAmount,
-        priceRoute,
-        userAddress,
-        partner: 'paraswap.io',
-      },
-      {
-        ignoreChecks: true,
-      },
-    );
-    return swapParams as TxObject;
+    let deadline = Number((Math.floor(Date.now() / 1000) + 10 * 60).toFixed());
+
+    return await this.transactionBuilder.build({
+      priceRoute,
+      minMaxAmount: minMaxAmount.toString(),
+      userAddress,
+      partnerAddress: NULL_ADDRESS,
+      partnerFeePercent: '0',
+      deadline: deadline.toString(),
+      uuid: uuid(),
+    });
   }
 }
 
+function send1WeiTo(token: Address, to: Address, network: Network) {
+  const tokens = Tokens[network];
+
+  const tokenSymbol = Object.keys(tokens).find(tokenSymbol => {
+    const curToken = tokens[tokenSymbol];
+    return curToken.address === token;
+  });
+
+  const holders = Holders[network];
+  const holder = holders[tokenSymbol!];
+
+  return {
+    from: holder,
+    to: token,
+    data: erc20Interface.encodeFunctionData('transfer', [to, '1']),
+    value: '0',
+  };
+}
+
+function checkBalanceOf(token: Address, holder: Address) {
+  return {
+    from: NULL_ADDRESS,
+    to: token,
+    data: erc20Interface.encodeFunctionData('balanceOf', [holder]),
+    value: '0',
+  };
+}
+
+function allowAugustusV6(
+  tokenAddress: Address,
+  holderAddress: Address,
+  network: Network,
+) {
+  const augustusV6Address = generateConfig(network).augustusV6Address;
+
+  return {
+    from: holderAddress,
+    to: tokenAddress,
+    data: erc20Interface.encodeFunctionData('approve', [
+      augustusV6Address,
+      MAX_UINT,
+    ]),
+    value: '0',
+  };
+}
+
 function allowTokenTransferProxyParams(
   tokenAddress: Address,
   holderAddress: Address,
@@ -264,17 +371,18 @@ export async function testE2E(
   senderAddress: Address,
   _amount: string,
   swapSide = SwapSide.SELL,
-  dexKey: string,
+  dexKeys: string | string[],
   contractMethod: ContractMethod,
   network: Network = Network.MAINNET,
   _0: Provider,
-  poolIdentifiers?: string[],
+  poolIdentifiers?: { [key: string]: string[] | null } | null,
   limitOrderProvider?: DummyLimitOrderProvider,
   transferFees?: TransferFeeParams,
   // Specified in BPS: part of 10000
   slippage?: number,
   sleepMs?: number,
   replaceTenderlyWithEstimateGas?: boolean,
+  forceRoute?: AddressOrSymbol[],
 ) {
   const amount = BigInt(_amount);
 
@@ -287,8 +395,13 @@ export async function testE2E(
     const allowanceTx = await ts.simulate(
       allowTokenTransferProxyParams(srcToken.address, senderAddress, network),
     );
+    const augustusV6Allowance = await ts.simulate(
+      allowAugustusV6(srcToken.address, senderAddress, network),
+    );
     if (!allowanceTx.success) console.log(allowanceTx.url);
+    if (!augustusV6Allowance.success) console.log(augustusV6Allowance.url);
     expect(allowanceTx!.success).toEqual(true);
+    expect(augustusV6Allowance!.success).toEqual(true);
   }
 
   if (deployedTestContractAddress) {
@@ -354,8 +467,8 @@ export async function testE2E(
   const useAPI = testingEndpoint && !poolIdentifiers;
   // The API currently doesn't allow for specifying poolIdentifiers
   const paraswap: IParaSwapSDK = useAPI
-    ? new APIParaswapSDK(network, dexKey)
-    : new LocalParaswapSDK(network, dexKey, '', limitOrderProvider);
+    ? new APIParaswapSDK(network, dexKeys, '')
+    : new LocalParaswapSDK(network, dexKeys, '', limitOrderProvider);
 
   if (paraswap.initializePricing) await paraswap.initializePricing();
 
@@ -378,9 +491,66 @@ export async function testE2E(
       contractMethod,
       poolIdentifiers,
       transferFees,
+      forceRoute,
     );
+
+    console.log('PRICE ROUTE: ', util.inspect(priceRoute, false, null, true));
     expect(parseFloat(priceRoute.destAmount)).toBeGreaterThan(0);
 
+    // send 1 wei of src token to AugustusV6 and Executors
+    // const config = generateConfig(network);
+    // const augustusV6Address = config.augustusV6Address!;
+    // const executorsAddresses = Object.values(config.executorsAddresses!);
+    // const addresses = [...executorsAddresses, augustusV6Address];
+
+    // for await (const a of addresses) {
+    //   const src =
+    //     srcToken.address.toLowerCase() === ETHER_ADDRESS
+    //       ? config.wrappedNativeTokenAddress
+    //       : srcToken.address.toLowerCase();
+    //   const dest =
+    //     destToken.address.toLowerCase() === ETHER_ADDRESS
+    //       ? config.wrappedNativeTokenAddress
+    //       : destToken.address.toLowerCase();
+    //
+    //   if (priceRoute.bestRoute[0].swaps.length > 0) {
+    //     const intermediateToken =
+    //       priceRoute.bestRoute[0].swaps[0].destToken.toLowerCase() ===
+    //       ETHER_ADDRESS
+    //         ? config.wrappedNativeTokenAddress
+    //         : priceRoute.bestRoute[0].swaps[0].destToken.toLowerCase();
+    //
+    //     await ts.simulate(send1WeiTo(intermediateToken, a, network));
+    //   }
+    //
+    //   await ts.simulate(send1WeiTo(src, a, network));
+    //   await ts.simulate(send1WeiTo(dest, a, network));
+    // }
+    //
+    // for await (const a of addresses) {
+    //   const src =
+    //     srcToken.address.toLowerCase() === ETHER_ADDRESS
+    //       ? config.wrappedNativeTokenAddress
+    //       : srcToken.address.toLowerCase();
+    //   const dest =
+    //     destToken.address.toLowerCase() === ETHER_ADDRESS
+    //       ? config.wrappedNativeTokenAddress
+    //       : destToken.address.toLowerCase();
+    //
+    //   if (priceRoute.bestRoute[0].swaps.length > 0) {
+    //     const intermediateToken =
+    //       priceRoute.bestRoute[0].swaps[0].destToken.toLowerCase() ===
+    //       ETHER_ADDRESS
+    //         ? config.wrappedNativeTokenAddress
+    //         : priceRoute.bestRoute[0].swaps[0].destToken.toLowerCase();
+    //
+    //     await ts.simulate(checkBalanceOf(intermediateToken, a));
+    //   }
+    //
+    //   await ts.simulate(checkBalanceOf(src, a));
+    //   await ts.simulate(checkBalanceOf(dest, a));
+    // }
+
     // Calculate slippage. Default is 1%
     const _slippage = slippage || 100;
     const minMaxAmount =
@@ -403,7 +573,11 @@ export async function testE2E(
         }, Difference: ${parseInt(priceRoute.gasCost) - parseInt(gasUsed)}`,
       );
     }
-    console.log(`Tenderly URL: ${swapTx!.url}`);
+    console.log(
+      `${swapSide}: ${srcToken.address} -> ${destToken.address} (${
+        priceRoute.contractMethod
+      })\nTenderly URL: ${swapTx!.url}`,
+    );
     expect(swapTx!.success).toEqual(true);
   } finally {
     if (paraswap.releaseResources) {
@@ -420,10 +594,10 @@ export type TestParamE2E = {
   thirdPartyAddress?: Address;
   _amount: string;
   swapSide: SwapSide;
-  dexKey: string;
+  dexKeys: string | string[];
   contractMethod: ContractMethod;
   network: Network;
-  poolIdentifiers?: string[];
+  poolIdentifiers?: { [key: string]: string[] | null } | null;
   limitOrderProvider?: DummyLimitOrderProvider;
   transferFees?: TransferFeeParams;
   srcTokenBalanceOverrides?: Record<Address, string>;
@@ -458,7 +632,7 @@ export async function newTestE2E({
   thirdPartyAddress,
   _amount,
   swapSide,
-  dexKey,
+  dexKeys,
   contractMethod,
   network,
   poolIdentifiers,
@@ -535,7 +709,7 @@ export async function newTestE2E({
   // The API currently doesn't allow for specifying poolIdentifiers
   const paraswap: IParaSwapSDK = new LocalParaswapSDK(
     network,
-    dexKey,
+    dexKeys,
     '',
     limitOrderProvider,
   );
@@ -615,7 +789,6 @@ export async function newTestE2E({
       destToken.applyOverrides(stateOverrides);
 
       const swapTx = await ts.simulate(swapParams, stateOverrides);
-      console.log(`${srcToken.address}_${destToken.address}_${dexKey!}`);
       // Only log gas estimate if testing against API
       if (useAPI)
         console.log(
@@ -645,3 +818,124 @@ export const getEnv = (envName: string, optional: boolean = false): string => {
 
   return process.env[envName]!;
 };
+
+// poolIdentifiers?: { [key: string]: string[] | null } | null,
+// limitOrderProvider?: DummyLimitOrderProvider,
+// transferFees?: TransferFeeParams,
+// // Specified in BPS: part of 10000
+// slippage?: number,
+// sleepMs?: number,
+// replaceTenderlyWithEstimateGas?: boolean,
+// forceRoute?: AddressOrSymbol[],
+export function testE2E_V6(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  forceRoute: AddressOrSymbol[],
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+  const wrappedNativeTokenSymbol = WrappedNativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${wrappedNativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[wrappedNativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[wrappedNativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${wrappedNativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[wrappedNativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}

package/tests/v6/executors.test.ts

@@ -0,0 +1,110 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { OptimalRate } from '@paraswap/core';
+import {
+  ContractsAugustusV6,
+  runE2ETest as runForkE2ETest,
+} from './utils-e2e-v6';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { Holders, Tokens } from '../constants-e2e';
+
+jest.setTimeout(1000 * 120);
+
+type ForkMetadata = {
+  forkId: string;
+  lastTx: string;
+  blockNumber: number;
+  network: number;
+  contracts: ContractsAugustusV6;
+};
+
+const forceNewDeployment = false;
+// const network = 'polygon';
+// const network = 'arbitrum';
+// const network = 'avalanche';
+const network = 'mainnet';
+
+async function deployAugustusOnFork(
+  network: number,
+  blockNumber: number,
+): Promise<ForkMetadata> {
+  console.log(
+    `Locally deploying fork for block ${blockNumber} with AugustusV6 contracts`,
+  );
+  const { data } = await axios.post<ForkMetadata>(
+    // local server from contracts-v6
+    `http://localhost:3000/deploy-fork`,
+    {
+      network,
+      blockNumber,
+      forceNewDeployment,
+    },
+  );
+  return data;
+}
+
+describe('Executors: Price Route Tests', () => {
+  // Dynamically load and test each price route file in the directory
+  const routePath = `./price-routes/${network}`;
+  const priceRoutesDir = path.join(__dirname, routePath);
+  const priceRouteFiles = fs.readdirSync(priceRoutesDir);
+
+  priceRouteFiles.forEach(file => {
+    if (file === 'balancer-v2-2.test.json')
+      it(`file: ${file}`, async () => {
+        const {
+          priceRoute,
+          metadata,
+        }: {
+          priceRoute: OptimalRate;
+          metadata: ForkMetadata;
+        } = require(path.join(priceRoutesDir, file));
+        let forkMetadata: ForkMetadata = metadata;
+        if (!forkMetadata?.contracts || forceNewDeployment) {
+          forkMetadata = await deployAugustusOnFork(
+            priceRoute.network,
+            priceRoute.blockNumber,
+          );
+          saveForkMetadata(
+            forkMetadata,
+            priceRoute as OptimalRate,
+            `${routePath}/${file}`,
+          );
+        }
+
+        const srcTokenSymbol = Object.entries(Tokens[priceRoute.network]).find(
+          ([key, token]) =>
+            token.address.toLowerCase() === priceRoute.srcToken.toLowerCase(),
+        )?.[0];
+
+        if (!srcTokenSymbol) throw new Error('srcTokenSymbol not found');
+
+        await runForkE2ETest(
+          priceRoute as OptimalRate,
+          Holders[priceRoute.network][srcTokenSymbol],
+          forkMetadata.forkId,
+          forkMetadata.lastTx,
+          forkMetadata.contracts,
+        );
+      });
+  });
+});
+
+function saveForkMetadata(
+  metadata: ForkMetadata,
+  priceRoute: OptimalRate,
+  relativeFilePath: string,
+) {
+  try {
+    const absoluteFilePath = path.join(__dirname, relativeFilePath);
+    fs.writeFileSync(
+      absoluteFilePath,
+      JSON.stringify({ metadata, priceRoute }, null, 2),
+    );
+  } catch (err) {
+    console.error(`Error writing file to disk: ${err}`);
+  }
+}