@paraswap/dex-lib 4.0.22 → 4.0.23

package/tests/tenderly-simulation.ts

@@ -1,17 +1,16 @@
 /* eslint-disable no-console */
 import axios from 'axios';
-import { Address } from '@paraswap/core';
 import { TxObject } from '../src/types';
 import { StateOverrides, StateSimulateApiOverride } from './smart-tokens';
-import { StaticJsonRpcProvider, Provider } from '@ethersproject/providers';
-import Web3 from 'web3';
+import { Provider, StaticJsonRpcProvider } from '@ethersproject/providers';
+import { ethers } from 'ethers';
+import { Network } from '../build/constants';
+import { Address } from '@paraswap/core';
 
 const TENDERLY_TOKEN = process.env.TENDERLY_TOKEN;
 const TENDERLY_ACCOUNT_ID = process.env.TENDERLY_ACCOUNT_ID;
 const TENDERLY_PROJECT = process.env.TENDERLY_PROJECT;
-const TENDERLY_FORK_ID = process.env.TENDERLY_FORK_ID;
-const TENDERLY_TEST_NET_RPC = process.env.TENDERLY_TEST_NET_RPC;
-const TENDERLY_FORK_LAST_TX_ID = process.env.TENDERLY_FORK_LAST_TX_ID;
+const TENDERLY_VNET_ID = process.env.TENDERLY_VNET_ID;
 
 export type SimulationResult = {
   success: boolean;
@@ -21,9 +20,11 @@ export type SimulationResult = {
 };
 
 export interface TransactionSimulator {
-  forkId: string;
+  vnetId: string;
   setup(): Promise<void>;
 
+  getChainNameByChainId(network: number): string;
+
   simulate(
     params: TxObject,
     stateOverrides?: StateOverrides,
@@ -31,12 +32,16 @@ export interface TransactionSimulator {
 }
 
 export class EstimateGasSimulation implements TransactionSimulator {
-  forkId: string = '0';
+  vnetId: string = '0';
 
   constructor(private provider: Provider) {}
 
   async setup() {}
 
+  getChainNameByChainId(network: number) {
+    return '';
+  }
+
   async simulate(
     params: TxObject,
     _: StateOverrides,
@@ -57,59 +62,106 @@ export class EstimateGasSimulation implements TransactionSimulator {
 }
 
 export class TenderlySimulation implements TransactionSimulator {
-  testNetRPC: StaticJsonRpcProvider | null = null;
-  lastTx: string = '';
-  forkId: string = '';
+  vnetId: string = '';
+  rpcURL: string = '';
   maxGasLimit = 80000000;
 
-  constructor(
-    private network: Number = 1,
-    forkId?: string,
-    lastTransactionId?: string,
-  ) {
-    if (forkId && lastTransactionId) {
-      this.forkId = forkId;
-      this.lastTx = lastTransactionId;
-    }
+  private readonly chainIdToChainNameMap: { [key: number]: string } = {
+    [Network.MAINNET]: 'mainnet',
+    [Network.BSC]: 'bnb',
+    [Network.POLYGON]: 'polygon',
+    [Network.AVALANCHE]: 'avalanche-mainnet',
+    [Network.FANTOM]: 'fantom',
+    [Network.ARBITRUM]: 'arbitrum',
+    [Network.OPTIMISM]: 'optimistic',
+    [Network.GNOSIS]: 'gnosis-chain',
+    [Network.BASE]: 'base',
+  };
+
+  constructor(private network: number = 1) {}
+
+  getChainNameByChainId(network: number): string {
+    return this.chainIdToChainNameMap[network];
   }
 
   async setup() {
-    // Fork the mainnet
     if (!TENDERLY_TOKEN)
       throw new Error(
         `TenderlySimulation_setup: TENDERLY_TOKEN not found in the env`,
       );
 
-    if (this.forkId && this.lastTx) return;
+    const findAdminRPC = (rpcs: { name: string; url: string }[]) => {
+      return rpcs.find(
+        rpc => rpc.name.toLowerCase() === 'Admin RPC'.toLowerCase(),
+      );
+    };
 
-    if (TENDERLY_FORK_ID) {
-      if (!TENDERLY_FORK_LAST_TX_ID) throw new Error('Always set last tx id');
-      this.forkId = TENDERLY_FORK_ID;
-      this.lastTx = TENDERLY_FORK_LAST_TX_ID;
-      return;
-    }
+    if (TENDERLY_VNET_ID) {
+      this.vnetId = TENDERLY_VNET_ID;
+
+      try {
+        let res = await axios.get(
+          `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/vnets/${this.vnetId}`,
+          {
+            timeout: 200000,
+            headers: {
+              'x-access-key': TENDERLY_TOKEN,
+            },
+          },
+        );
+
+        const rpc = findAdminRPC(res.data.rpcs);
+
+        if (!rpc) {
+          throw new Error(`RPC url was not found for testnet: ${this.vnetId}`);
+        }
+
+        this.rpcURL = rpc.url;
+      } catch (e) {
+        console.error(`TenderlySimulation_setup:`, e);
+        throw e;
+      }
 
-    if (TENDERLY_TEST_NET_RPC) {
-      this.testNetRPC = new StaticJsonRpcProvider(TENDERLY_TEST_NET_RPC);
       return;
     }
 
     try {
       await process.nextTick(() => {}); // https://stackoverflow.com/questions/69169492/async-external-function-leaves-open-handles-jest-supertest-express
       let res = await axios.post(
-        `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/fork`,
+        `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/vnets`,
         {
-          network_id: this.network.toString(),
+          slug: `e2e-tests-testnetwork-${this.network.toString()}-${Date.now()}`,
+          fork_config: {
+            network_id: this.network,
+          },
+          virtual_network_config: {
+            chain_config: {
+              chain_id: this.network,
+            },
+          },
+          sync_state_config: {
+            enabled: false,
+          },
+          explorer_page_config: {
+            enabled: true,
+            verification_visibility: 'bytecode',
+          },
         },
         {
-          timeout: 20000,
+          timeout: 200000,
           headers: {
             'x-access-key': TENDERLY_TOKEN,
           },
         },
       );
-      this.forkId = res.data.simulation_fork.id;
-      this.lastTx = res.data.root_transaction.id;
+
+      this.vnetId = res.data.id;
+      const rpc = findAdminRPC(res.data.rpcs);
+      if (!rpc) {
+        throw new Error(`RPC url was not found for testnet: ${this.vnetId}`);
+      }
+
+      this.rpcURL = rpc.url;
     } catch (e) {
       console.error(`TenderlySimulation_setup:`, e);
       throw e;
@@ -117,24 +169,13 @@ export class TenderlySimulation implements TransactionSimulator {
   }
 
   async simulate(params: TxObject, stateOverrides?: StateOverrides) {
-    let _params = {
-      from: params.from,
-      to: params.to,
-      save: true,
-      root: this.lastTx,
-      value: params.value || '0',
-      gas: this.maxGasLimit,
-      input: params.data,
-      state_objects: {},
-    };
     try {
-      if (this.testNetRPC) return this.executeTransactionOnTestnet(params);
+      let stateOverridesParams = {};
 
       if (stateOverrides) {
         await process.nextTick(() => {}); // https://stackoverflow.com/questions/69169492/async-external-function-leaves-open-handles-jest-supertest-express
         const result = await axios.post(
-          `
-        https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/contracts/encode-states`,
+          `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/contracts/encode-states`,
           stateOverrides,
           {
             headers: {
@@ -143,7 +184,7 @@ export class TenderlySimulation implements TransactionSimulator {
           },
         );
 
-        _params.state_objects = Object.keys(result.data.stateOverrides).reduce(
+        stateOverridesParams = Object.keys(result.data.stateOverrides).reduce(
           (acc, contract) => {
             const _storage = result.data.stateOverrides[contract].value;
 
@@ -154,12 +195,30 @@ export class TenderlySimulation implements TransactionSimulator {
           },
           {} as Record<Address, StateSimulateApiOverride>,
         );
+
+        await this.executeStateOverrides(stateOverridesParams);
       }
 
       await process.nextTick(() => {}); // https://stackoverflow.com/questions/69169492/async-external-function-leaves-open-handles-jest-supertest-express
       const { data } = await axios.post(
-        `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/fork/${this.forkId}/simulate`,
-        _params,
+        `https://api.tenderly.co/api/v1/account/${TENDERLY_ACCOUNT_ID}/project/${TENDERLY_PROJECT}/vnets/${this.vnetId}/transactions`,
+        {
+          callArgs: {
+            from: params.from,
+            to: params.to,
+            value:
+              params.value === '0'
+                ? '0x0'
+                : ethers.utils.hexStripZeros(
+                    ethers.utils.hexlify(BigInt(params.value)),
+                  ),
+            gas: ethers.utils.hexStripZeros(
+              ethers.utils.hexlify(BigInt(this.maxGasLimit)),
+            ),
+            data: params.data,
+          },
+          blockNumber: 'pending',
+        },
         {
           timeout: 30 * 1000,
           headers: {
@@ -168,20 +227,22 @@ export class TenderlySimulation implements TransactionSimulator {
         },
       );
 
-      const lastTx = data.simulation.id;
-      if (data.transaction.status) {
-        this.lastTx = lastTx;
+      if (data.status === 'success') {
         return {
           success: true,
-          gasUsed: data.transaction.gas_used,
-          url: `https://dashboard.tenderly.co/${TENDERLY_ACCOUNT_ID}/${TENDERLY_PROJECT}/fork/${this.forkId}/simulation/${lastTx}`,
-          transaction: data.transaction,
+          gasUsed: data.gasUsed,
+          url: `https://dashboard.tenderly.co/${TENDERLY_ACCOUNT_ID}/${TENDERLY_PROJECT}/testnet/${
+            this.vnetId
+          }/tx/${this.chainIdToChainNameMap[this.network]}/${data.id}`,
+          transaction: data.input,
         };
       } else {
         return {
           success: false,
-          url: `https://dashboard.tenderly.co/${TENDERLY_ACCOUNT_ID}/${TENDERLY_PROJECT}/fork/${this.forkId}/simulation/${lastTx}`,
-          error: `Simulation failed: ${data.transaction.error_info.error_message} at ${data.transaction.error_info.address}`,
+          url: `https://dashboard.tenderly.co/${TENDERLY_ACCOUNT_ID}/${TENDERLY_PROJECT}/testnet/${
+            this.vnetId
+          }/tx/${this.chainIdToChainNameMap[this.network]}/${data.id}`,
+          error: `Simulation failed ${data.error_reason}`,
         };
       }
     } catch (e) {
@@ -191,31 +252,35 @@ export class TenderlySimulation implements TransactionSimulator {
     }
   }
 
-  async executeTransactionOnTestnet(params: TxObject) {
-    const txParams = {
-      from: params.from,
-      to: params.to,
-      value: Web3.utils.toHex(params.value || '0'),
-      data: params.data,
-      gas: '0x4c4b40', // 5,000,000
-      gasPrice: '0x0', // 0
-    };
-    const txHash = await this.testNetRPC!.send('eth_sendTransaction', [
-      txParams,
-    ]);
-    const transaction = await this.testNetRPC!.waitForTransaction(txHash);
-    if (transaction.status) {
-      return {
-        success: true,
-        url: txHash,
-        gasUsed: transaction.gasUsed.toString(),
-        transaction,
-      };
-    } else {
-      return {
-        success: false,
-        error: `Transaction on testnet failed, hash: ${txHash}`,
-      };
+  async executeStateOverrides(
+    stateOverridesParams: Record<string, StateSimulateApiOverride>,
+  ) {
+    if (!this.rpcURL) {
+      throw new Error(
+        `rpcURL is not defined for testnet: ${this.vnetId} (https://dashboard.tenderly.co/${TENDERLY_ACCOUNT_ID}/${TENDERLY_PROJECT}/testnet/${this.vnetId}`,
+      );
     }
+
+    const testNetRPC = new StaticJsonRpcProvider(this.rpcURL);
+    await Promise.all(
+      Object.keys(stateOverridesParams).map(async addr => {
+        const storage = stateOverridesParams[addr].storage;
+
+        await Promise.all(
+          Object.keys(storage).map(async slot => {
+            const txHash = await testNetRPC!.send('tenderly_setStorageAt', [
+              addr,
+              slot,
+              storage[slot],
+            ]);
+
+            const transaction = await testNetRPC!.waitForTransaction(txHash);
+            if (!transaction.status) {
+              console.log(`Transaction failed: ${txHash}`);
+            }
+          }),
+        );
+      }),
+    );
   }
 }

package/tests/utils-e2e.ts

@@ -446,7 +446,7 @@ export async function testE2E(
       formatDeployMessage(
         'adapter',
         contractAddress,
-        ts.forkId,
+        ts.vnetId,
         testContractName || '',
         testContractRelativePath || '',
       ),
@@ -486,7 +486,9 @@ export async function testE2E(
 
   if (paraswap.dexHelper?.replaceProviderWithRPC) {
     paraswap.dexHelper?.replaceProviderWithRPC(
-      `https://rpc.tenderly.co/fork/${ts.forkId}`,
+      `https://virtual.${ts.getChainNameByChainId(network)}.rpc.tenderly.co/${
+        ts.vnetId
+      }`,
     );
   }
 
@@ -572,6 +574,7 @@ export async function testE2E(
     );
 
     const swapTx = await ts.simulate(swapParams);
+
     // Only log gas estimate if testing against API
     if (useAPI) {
       const gasUsed = swapTx.gasUsed || '0';

package/.vscode/launch.json

@@ -1,53 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Current",
-      "program": "${file}",
-      "preLaunchTask": "npm: build",
-      "sourceMaps": true,
-      "smartStep": true,
-      "internalConsoleOptions": "openOnSessionStart",
-      "outFiles": ["${workspaceFolder}/build/**/*.js"]
-    },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Debug dex integration",
-      "program": "${workspaceFolder}/node_modules/ts-node/dist/bin.js",
-      "args": [
-        "--project",
-        "tsconfig.json",
-        // "${workspaceFolder}/src/dex/algebra/scripts/validate-state.ts",
-        "${workspaceFolder}/src/dex/camelot/camelot-pool-discovery.test.ts",
-        // "${workspaceFolder}/src/dex/solidly-v3/scripts/check-event-pool-event.ts",
-        // "${workspaceFolder}/scripts/dex-integration.ts",
-        "test",
-        "wombat"
-      ],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "runtimeArgs": ["--nolazy"],
-      "sourceMaps": true,
-      "smartStep": true,
-      "skipFiles": ["<node_internals>/**"],
-      "cwd": "${workspaceFolder}"
-    },
-    {
-      "type": "node",
-      "name": "Jest file",
-      "request": "launch",
-      "program": "${workspaceFolder}/node_modules/jest/bin/jest.js",
-      // "program": "${workspaceFolder}/src/dex/camelot/scripts/validate-state.ts",
-      // "args": ["src/dex/balancer-v1/balancer-v1-e2e.test.ts"],
-      // "args": ["${relativeFile}"],
-      "args": ["${file}"],
-      "cwd": "${workspaceRoot}",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "sourceMaps": true
-    }
-  ]
-}

package/.vscode/settings.json

@@ -1,2 +0,0 @@
-{
-}

package/.vscode/tasks.json

@@ -1,15 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "tsc: build - tsconfig.json",
-      "type": "typescript",
-      "tsconfig": "tsconfig.json",
-      "problemMatcher": ["$tsc"],
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    }
-  ]
-}