@paraswap/dex-lib 2.20.3 → 2.21.1-chronos

package/tests/utils-e2e.ts

@@ -29,37 +29,12 @@ import { constructSimpleSDK, SimpleFetchSDK } from '@paraswap/sdk';
 import axios from 'axios';
 import { SmartToken, StateOverrides } from './smart-tokens';
 import { GIFTER_ADDRESS } from './constants-e2e';
-import { generateDeployBytecode, sleep } from './utils';
+import { sleep } from './utils';
 import { assert } from 'ts-essentials';
 
 export const testingEndpoint = process.env.E2E_TEST_ENDPOINT;
 
-const testContractProjectRootPath = process.env.TEST_CONTRACT_PROJECT_ROOT_PATH;
-const testContractName = process.env.TEST_CONTRACT_NAME;
-const testContractConfigFileName = process.env.TEST_CONTRACT_CONFIG_FILE_NAME;
-const testContractRelativePath = process.env.TEST_CONTRACT_RELATIVE_PATH;
-// Comma separated fields from config or actual values
-const testContractDeployArgs = process.env.TEST_CONTRACT_DEPLOY_ARGS;
-
-// If you want to test against deployed and verified contract
-const deployedTestContractAddress = process.env.DEPLOYED_TEST_CONTRACT_ADDRESS;
-const testContractType = process.env.TEST_CONTRACT_TYPE;
-
-// Only for router tests
-const testDirectRouterAbiPath = process.env.TEST_DIRECT_ROUTER_ABI_PATH;
-
-const directRouterIface = new Interface(
-  testDirectRouterAbiPath ? require(testDirectRouterAbiPath) : '[]',
-);
-
-const testContractBytecode = generateDeployBytecode(
-  testContractProjectRootPath,
-  testContractName,
-  testContractConfigFileName,
-  testContractRelativePath,
-  testContractDeployArgs,
-  testContractType,
-);
+const adapterBytecode = '';
 
 const erc20Interface = new Interface(Erc20ABI);
 const augustusInterface = new Interface(AugustusABI);
@@ -171,7 +146,7 @@ function allowTokenTransferProxyParams(
   };
 }
 
-function deployContractParams(bytecode: string, network = Network.MAINNET) {
+function deployAdapterParams(bytecode: string, network = Network.MAINNET) {
   const ownerAddress = DEPLOYER_ADDRESS[network];
   if (!ownerAddress) throw new Error('No deployer address set for network');
   return {
@@ -181,51 +156,13 @@ function deployContractParams(bytecode: string, network = Network.MAINNET) {
   };
 }
 
-function augustusSetImplementationParams(
-  contractAddress: Address,
-  network: Network,
-  functionName: string,
-) {
+function whiteListAdapterParams(contractAddress: Address, network: Network) {
   const augustusAddress = generateConfig(network).augustusAddress;
   if (!augustusAddress) throw new Error('No whitelist address set for network');
   const ownerAddress = MULTISIG[network];
   if (!ownerAddress) throw new Error('No whitelist owner set for network');
-
-  return {
-    from: ownerAddress,
-    to: augustusAddress,
-    data: augustusInterface.encodeFunctionData('setImplementation', [
-      directRouterIface.getSighash(functionName),
-      contractAddress,
-    ]),
-    value: '0',
-  };
-}
-
-function augustusGrantRoleParams(
-  contractAddress: Address,
-  network: Network,
-  type: string = 'adapter',
-) {
-  const augustusAddress = generateConfig(network).augustusAddress;
-  if (!augustusAddress) throw new Error('No whitelist address set for network');
-  const ownerAddress = MULTISIG[network];
-  if (!ownerAddress) throw new Error('No whitelist owner set for network');
-
-  let role: string;
-  switch (type) {
-    case 'adapter':
-      role =
-        '0x8429d542926e6695b59ac6fbdcd9b37e8b1aeb757afab06ab60b1bb5878c3b49';
-      break;
-    case 'router':
-      role =
-        '0x7a05a596cb0ce7fdea8a1e1ec73be300bdb35097c944ce1897202f7a13122eb2';
-      break;
-    default:
-      throw new Error(`Unrecognized type ${type}`);
-  }
-
+  const role =
+    '0x8429d542926e6695b59ac6fbdcd9b37e8b1aeb757afab06ab60b1bb5878c3b49';
   return {
     from: ownerAddress,
     to: augustusAddress,
@@ -237,21 +174,6 @@ function augustusGrantRoleParams(
   };
 }
 
-export function formatDeployMessage(
-  type: 'router' | 'adapter',
-  address: Address,
-  forkId: string,
-  contractName: string,
-  contractPath: string,
-) {
-  // This formatting is useful for verification on Tenderly
-  return `Deployed ${type} contract with env params:
-    TENDERLY_FORK_ID=${forkId}
-    TENDERLY_VERIFY_CONTRACT_ADDRESS=${address}
-    TENDERLY_VERIFY_CONTRACT_NAME=${contractName}
-    TENDERLY_VERIFY_CONTRACT_PATH=${contractPath}`;
-}
-
 export async function testE2E(
   srcToken: Token,
   destToken: Token,
@@ -261,13 +183,12 @@ export async function testE2E(
   dexKey: string,
   contractMethod: ContractMethod,
   network: Network = Network.MAINNET,
-  _0: Provider,
+  provider: Provider,
   poolIdentifiers?: string[],
   limitOrderProvider?: DummyLimitOrderProvider,
   transferFees?: TransferFeeParams,
   // Specified in BPS: part of 10000
   slippage?: number,
-  sleepMs?: number,
 ) {
   const amount = BigInt(_amount);
   const ts = new TenderlySimulation(network);
@@ -281,63 +202,26 @@ export async function testE2E(
     expect(allowanceTx!.success).toEqual(true);
   }
 
-  if (deployedTestContractAddress) {
-    const whitelistTx = await ts.simulate(
-      augustusGrantRoleParams(
-        deployedTestContractAddress,
-        network,
-        testContractType || 'adapter',
-      ),
-    );
-    expect(whitelistTx.success).toEqual(true);
-
-    if (testContractType === 'router') {
-      const setImplementationTx = await ts.simulate(
-        augustusSetImplementationParams(
-          deployedTestContractAddress,
-          network,
-          contractMethod,
-        ),
-      );
-      expect(setImplementationTx.success).toEqual(true);
-    }
-  } else if (testContractBytecode) {
+  if (adapterBytecode) {
     const deployTx = await ts.simulate(
-      deployContractParams(testContractBytecode, network),
+      deployAdapterParams(adapterBytecode, network),
     );
 
     expect(deployTx.success).toEqual(true);
-
-    const contractAddress =
+    const adapterAddress =
       deployTx.transaction.transaction_info.contract_address;
     console.log(
-      formatDeployMessage(
-        'adapter',
-        contractAddress,
-        ts.forkId,
-        testContractName || '',
-        testContractRelativePath || '',
-      ),
+      'Deployed adapter to address',
+      adapterAddress,
+      'used',
+      deployTx.gasUsed,
+      'gas',
     );
+
     const whitelistTx = await ts.simulate(
-      augustusGrantRoleParams(
-        contractAddress,
-        network,
-        testContractType || 'adapter',
-      ),
+      whiteListAdapterParams(adapterAddress, network),
     );
     expect(whitelistTx.success).toEqual(true);
-
-    if (testContractType === 'router') {
-      const setImplementationTx = await ts.simulate(
-        augustusSetImplementationParams(
-          contractAddress,
-          network,
-          contractMethod,
-        ),
-      );
-      expect(setImplementationTx.success).toEqual(true);
-    }
   }
 
   const useAPI = testingEndpoint && !poolIdentifiers;
@@ -348,10 +232,6 @@ export async function testE2E(
 
   if (paraswap.initializePricing) await paraswap.initializePricing();
 
-  if (sleepMs) {
-    await sleep(sleepMs);
-  }
-
   if (paraswap.dexHelper?.replaceProviderWithRPC) {
     paraswap.dexHelper?.replaceProviderWithRPC(
       `https://rpc.tenderly.co/fork/${ts.forkId}`,
@@ -465,13 +345,13 @@ export async function newTestE2E({
     await ts.setup();
   }
 
-  if (useTenderly && testContractBytecode) {
+  if (useTenderly && adapterBytecode) {
     assert(
       ts instanceof TenderlySimulation,
       '`ts`  is not an instance of TenderlySimulation',
     );
     const deployTx = await ts.simulate(
-      deployContractParams(testContractBytecode, network),
+      deployAdapterParams(adapterBytecode, network),
     );
 
     expect(deployTx.success).toEqual(true);
@@ -486,7 +366,7 @@ export async function newTestE2E({
     );
 
     const whitelistTx = await ts.simulate(
-      augustusGrantRoleParams(adapterAddress, network),
+      whiteListAdapterParams(adapterAddress, network),
     );
     expect(whitelistTx.success).toEqual(true);
   }

package/tests/utils.ts

@@ -1,8 +1,5 @@
-/* eslint-disable no-console */
-import { ethers } from 'ethers';
 import { PoolPrices, PoolLiquidity, Address } from '../src/types';
 import { SwapSide } from '../src/constants';
-import { assert } from 'ts-essentials';
 
 // Assuming that the amounts are increasing at same interval, and start with 0
 export function checkPoolPrices(
@@ -76,52 +73,3 @@ export const sleep = (time: number) =>
   new Promise(resolve => {
     setTimeout(resolve, time);
   });
-
-export const generateDeployBytecode = (
-  testContractProjectRootPath: string | undefined,
-  testContractName: string | undefined,
-  testContractConfigFileName: string | undefined,
-  testContractRelativePath: string | undefined,
-  testContractDeployArgs: string | undefined,
-  testContractType: string | undefined,
-): string => {
-  if (
-    !testContractProjectRootPath ||
-    !testContractName ||
-    !testContractConfigFileName ||
-    !testContractRelativePath ||
-    !testContractDeployArgs ||
-    !testContractType
-  ) {
-    return '';
-  }
-
-  const artifactJsonPath = `${testContractProjectRootPath}/artifacts/${testContractName}.json`;
-  const configJsonPath = `${testContractProjectRootPath}/config/${testContractConfigFileName}.json`;
-  const fieldsToPickFromConfig = testContractDeployArgs.split(',');
-
-  const artifact = require(artifactJsonPath) as {
-    abi: ethers.ContractInterface;
-    bytecode: string;
-  };
-  // I don't want to type this testing thing. If something is wrong, I will just throw
-  const config = require(configJsonPath) as any;
-  const factory = new ethers.ContractFactory(artifact.abi, artifact.bytecode);
-
-  const args = fieldsToPickFromConfig.map(f => {
-    const value = config[f];
-    if (value === undefined) {
-      console.log(
-        `Field ${f} is not defined in configJsonPath=${configJsonPath}. Using value as it is`,
-      );
-      return f;
-    }
-    return value;
-  });
-
-  const deployedBytecode = factory.getDeployTransaction(...args).data;
-
-  assert(deployedBytecode !== undefined, 'deployedBytecode is undefined');
-
-  return deployedBytecode.toString();
-};