@paraswap/dex-lib 2.16.4 → 2.16.5-direct-swaps.0

package/tests/utils-e2e.ts

@@ -29,12 +29,37 @@ import { constructSimpleSDK, SimpleFetchSDK } from '@paraswap/sdk';
 import axios from 'axios';
 import { SmartToken, StateOverrides } from './smart-tokens';
 import { GIFTER_ADDRESS } from './constants-e2e';
-import { sleep } from './utils';
+import { generateDeployBytecode, sleep } from './utils';
 import { assert } from 'ts-essentials';
 
 export const testingEndpoint = process.env.E2E_TEST_ENDPOINT;
 
-const adapterBytecode = '';
+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 erc20Interface = new Interface(Erc20ABI);
 const augustusInterface = new Interface(AugustusABI);
@@ -146,7 +171,7 @@ function allowTokenTransferProxyParams(
   };
 }
 
-function deployAdapterParams(bytecode: string, network = Network.MAINNET) {
+function deployContractParams(bytecode: string, network = Network.MAINNET) {
   const ownerAddress = DEPLOYER_ADDRESS[network];
   if (!ownerAddress) throw new Error('No deployer address set for network');
   return {
@@ -156,13 +181,51 @@ function deployAdapterParams(bytecode: string, network = Network.MAINNET) {
   };
 }
 
-function whiteListAdapterParams(contractAddress: Address, network: Network) {
+function augustusSetImplementationParams(
+  contractAddress: Address,
+  network: Network,
+  functionName: string,
+) {
   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');
-  const role =
-    '0x8429d542926e6695b59ac6fbdcd9b37e8b1aeb757afab06ab60b1bb5878c3b49';
+
+  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}`);
+  }
+
   return {
     from: ownerAddress,
     to: augustusAddress,
@@ -174,6 +237,21 @@ function whiteListAdapterParams(contractAddress: Address, network: Network) {
   };
 }
 
+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,
@@ -183,7 +261,7 @@ export async function testE2E(
   dexKey: string,
   contractMethod: ContractMethod,
   network: Network = Network.MAINNET,
-  provider: Provider,
+  _0: Provider,
   poolIdentifiers?: string[],
   limitOrderProvider?: DummyLimitOrderProvider,
   transferFees?: TransferFeeParams,
@@ -202,26 +280,63 @@ export async function testE2E(
     expect(allowanceTx!.success).toEqual(true);
   }
 
-  if (adapterBytecode) {
+  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) {
     const deployTx = await ts.simulate(
-      deployAdapterParams(adapterBytecode, network),
+      deployContractParams(testContractBytecode, network),
     );
 
     expect(deployTx.success).toEqual(true);
-    const adapterAddress =
+
+    const contractAddress =
       deployTx.transaction.transaction_info.contract_address;
     console.log(
-      'Deployed adapter to address',
-      adapterAddress,
-      'used',
-      deployTx.gasUsed,
-      'gas',
+      formatDeployMessage(
+        'adapter',
+        contractAddress,
+        ts.forkId,
+        testContractName || '',
+        testContractRelativePath || '',
+      ),
     );
-
     const whitelistTx = await ts.simulate(
-      whiteListAdapterParams(adapterAddress, network),
+      augustusGrantRoleParams(
+        contractAddress,
+        network,
+        testContractType || 'adapter',
+      ),
     );
     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;
@@ -345,13 +460,13 @@ export async function newTestE2E({
     await ts.setup();
   }
 
-  if (useTenderly && adapterBytecode) {
+  if (useTenderly && testContractBytecode) {
     assert(
       ts instanceof TenderlySimulation,
       '`ts`  is not an instance of TenderlySimulation',
     );
     const deployTx = await ts.simulate(
-      deployAdapterParams(adapterBytecode, network),
+      deployContractParams(testContractBytecode, network),
     );
 
     expect(deployTx.success).toEqual(true);
@@ -366,7 +481,7 @@ export async function newTestE2E({
     );
 
     const whitelistTx = await ts.simulate(
-      whiteListAdapterParams(adapterAddress, network),
+      augustusGrantRoleParams(adapterAddress, network),
     );
     expect(whitelistTx.success).toEqual(true);
   }

package/tests/utils.ts

@@ -1,5 +1,8 @@
+/* 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(
@@ -73,3 +76,52 @@ 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();
+};