@paraswap/dex-lib 2.33.4-balancer-v2-multihop.2 → 2.35.0

package/src/dex/uniswap-v2/uniswap-v2-e2e-bsc.test.ts

@@ -2,7 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders, NativeTokenSymbols } from '../../../tests/constants-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
@@ -34,13 +38,7 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ],
-    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/uniswap-v3/uniswap-v3-e2e.test.ts

@@ -113,7 +113,6 @@ function testForNetwork(
 }
 
 describe('UniswapV3 E2E', () => {
-
   describe('UniswapV3', () => {
     const dexKey = 'UniswapV3';
 
@@ -790,32 +789,33 @@ describe('UniswapV3 E2E', () => {
         ],
       ]);
 
-      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
-        [
-          {
-            name: 'USDC',
-            sellAmount: '100000000000000000000',
-            buyAmount: '100000000000000000000',
-          },
-          {
-            name: 'USDT',
-            sellAmount: '100000000000000000000',
-            buyAmount: '100000000000000000000',
-          },
-        ],
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
         [
-          {
-            name: 'BNB',
-            sellAmount: '1000000000000000000',
-            buyAmount: '10000000000000000000',
-          },
-          {
-            name: 'USDT',
-            sellAmount: '1000000000000000000000',
-            buyAmount: '20000000000000000',
-          },
-        ],
-      ];
+          [
+            {
+              name: 'USDC',
+              sellAmount: '100000000000000000000',
+              buyAmount: '100000000000000000000',
+            },
+            {
+              name: 'USDT',
+              sellAmount: '100000000000000000000',
+              buyAmount: '100000000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'BNB',
+              sellAmount: '1000000000000000000',
+              buyAmount: '10000000000000000000',
+            },
+            {
+              name: 'USDT',
+              sellAmount: '1000000000000000000000',
+              buyAmount: '20000000000000000',
+            },
+          ],
+        ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
         describe(`${side}`, () => {
@@ -909,28 +909,33 @@ describe('UniswapV3 E2E', () => {
         ],
       ]);
 
-      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
-        [
-          {
-            name: 'FTM',
-            sellAmount: '100000000000000000',
-            buyAmount: '100000000',
-          },
-          {
-            name: 'USDC',
-            sellAmount: '100000000',
-            buyAmount: '100000000000000000',
-          },
-        ],
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
         [
-          {
-            name: 'WFTM',
-            sellAmount: '100000000000000',
-            buyAmount: '1000000000000000',
-          },
-          { name: 'WETH', sellAmount: '1000000000000000', buyAmount: '100000000000000' },
-        ],
-      ];
+          [
+            {
+              name: 'FTM',
+              sellAmount: '100000000000000000',
+              buyAmount: '100000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '100000000',
+              buyAmount: '100000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'WFTM',
+              sellAmount: '100000000000000',
+              buyAmount: '1000000000000000',
+            },
+            {
+              name: 'WETH',
+              sellAmount: '1000000000000000',
+              buyAmount: '100000000000000',
+            },
+          ],
+        ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
         describe(`${side}`, () => {

package/src/dex/uniswap-v3/uniswap-v3-integration.test.ts

@@ -629,15 +629,10 @@ describe('ChronosV3', () => {
   beforeEach(async () => {
     blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
     uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
-    uniswapV3Mainnet = new UniswapV3(
-      Network.ARBITRUM,
-      dexKey,
-      dexHelper,
-    );
+    uniswapV3Mainnet = new UniswapV3(Network.ARBITRUM, dexKey, dexHelper);
   });
 
   it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-
     const amounts = [0n, BI_POWS[6], 2000000n];
 
     const pools = await uniswapV3.getPoolIdentifiers(
@@ -687,7 +682,6 @@ describe('ChronosV3', () => {
   });
 
   it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-
     const amounts = [0n, BI_POWS[6], 2000000n];
 
     const pools = await uniswapV3.getPoolIdentifiers(
@@ -964,7 +958,5 @@ describe('SushiSwapV3', () => {
 
       expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
     });
-
   });
 });
-

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -91,7 +91,13 @@ export class UniswapV3
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(
-      _.pick(UniswapV3Config, ['UniswapV3', 'SushiSwapV3', 'QuickSwapV3.1', 'RamsesV2', 'ChronosV3']),
+      _.pick(UniswapV3Config, [
+        'UniswapV3',
+        'SushiSwapV3',
+        'QuickSwapV3.1',
+        'RamsesV2',
+        'ChronosV3',
+      ]),
     );
 
   logger: Logger;

package/src/lib/api3-feed.ts

@@ -0,0 +1,140 @@
+import { DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../composed-event-subscriber';
+import {
+  Address,
+  BlockHeader,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../types';
+import { Lens } from '../lens';
+import { Interface } from '@ethersproject/abi';
+import ProxyABI from '../abi/api3-proxy.json';
+import Api3ServerV1ABI from '../abi/api3-server-v1.json';
+
+export type Api3FeedSubscriberState = {
+  value: bigint;
+  timestamp: bigint;
+};
+
+export class Api3FeedSubscriber<State> extends PartialEventSubscriber<
+  State,
+  Api3FeedSubscriberState
+> {
+  static readonly proxyInterface = new Interface(ProxyABI);
+  static readonly api3ServerV1Iface = new Interface(Api3ServerV1ABI);
+  static readonly ANSWER_UPDATED_SIGNED_DATA =
+    Api3FeedSubscriber.api3ServerV1Iface.getEventTopic(
+      'UpdatedBeaconWithSignedData',
+    );
+  static readonly ANSWER_UPDATED_BEACON_SET_DATA =
+    Api3FeedSubscriber.api3ServerV1Iface.getEventTopic(
+      'UpdatedBeaconSetWithBeacons',
+    );
+
+  constructor(
+    private proxy: Address,
+    api3Server: Address,
+    private dataFeedId: string,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<Api3FeedSubscriberState>>,
+    logger: Logger,
+  ) {
+    super([api3Server], lens, logger);
+  }
+
+  static getApi3ServerV1MultiCallInput(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        Api3FeedSubscriber.proxyInterface.encodeFunctionData('api3ServerV1'),
+    };
+  }
+
+  static getDataFeedId(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        Api3FeedSubscriber.proxyInterface.encodeFunctionData('dataFeedId'),
+    };
+  }
+
+  static decodeDataFeedId(multicallOutput: MultiCallOutput) {
+    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'dataFeedId',
+      multicallOutput,
+    )[0];
+  }
+
+  static decodeApi3ServerV1Result(multicallOutput: MultiCallOutput): Address {
+    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'api3ServerV1',
+      multicallOutput,
+    )[0];
+  }
+
+  public processLog(
+    state: DeepReadonly<Api3FeedSubscriberState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<Api3FeedSubscriberState> | null {
+    if (log.topics[0] === Api3FeedSubscriber.ANSWER_UPDATED_SIGNED_DATA) {
+      const decoded = Api3FeedSubscriber.api3ServerV1Iface.decodeEventLog(
+        'UpdatedBeaconWithSignedData',
+        log.data,
+        log.topics,
+      );
+
+      if (decoded.beaconId !== this.dataFeedId) return null;
+
+      return {
+        value: BigInt(decoded.value.toString()),
+        timestamp: BigInt(decoded.timestamp.toString()),
+      };
+    } else if (
+      log.topics[0] === Api3FeedSubscriber.ANSWER_UPDATED_BEACON_SET_DATA
+    ) {
+      const decoded = Api3FeedSubscriber.api3ServerV1Iface.decodeEventLog(
+        'UpdatedBeaconSetWithBeacons',
+        log.data,
+        log.topics,
+      );
+
+      if (decoded.beaconSetId !== this.dataFeedId) return null;
+
+      return {
+        value: BigInt(decoded.value.toString()),
+        timestamp: BigInt(decoded.timestamp.toString()),
+      };
+    } else {
+      return null;
+    }
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return [
+      {
+        target: this.proxy,
+        callData: Api3FeedSubscriber.proxyInterface.encodeFunctionData('read'),
+      },
+    ];
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<Api3FeedSubscriberState> {
+    const decoded = Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'read',
+      multicallOutputs[0],
+    );
+    return {
+      value: BigInt(decoded.value.toString()),
+      timestamp: BigInt(decoded.timestamp.toString()),
+    };
+  }
+
+  public getLatestData(state: DeepReadonly<State>): bigint {
+    return this.lens.get()(state).value;
+  }
+}

package/src/lib/decoders.ts

@@ -1,5 +1,6 @@
 import { Result } from '@ethersproject/abi';
 import BigNumber from 'bignumber.js';
+import { BigNumber as EthersBigNumber } from 'ethers';
 import { BytesLike, defaultAbiCoder } from 'ethers/lib/utils';
 import _, { parseInt } from 'lodash';
 import { BN_0 } from '../bignumber-constants';
@@ -50,6 +51,18 @@ export const uint256ToBigInt = (
   return generalDecoder(result, ['uint256'], 0n, value => value[0].toBigInt());
 };
 
+export const uint128ToBigNumber = (
+  result: MultiResult<BytesLike> | BytesLike,
+): EthersBigNumber => {
+  return generalDecoder(result, ['uint128'], 0n, value => value[0]);
+};
+
+export const int24ToNumber = (
+  result: MultiResult<BytesLike> | BytesLike,
+): number => {
+  return generalDecoder(result, ['int24'], 0n, value => value[0]);
+};
+
 export const uint256ArrayDecode = (
   result: MultiResult<BytesLike> | BytesLike,
 ): bigint => {

package/src/stateful-event-subscriber.ts

@@ -18,6 +18,7 @@ type StateCache<State> = {
 export type InitializeStateOptions<State> = {
   state?: DeepReadonly<State>;
   initCallback?: (state: DeepReadonly<State>) => void;
+  forceRegenerate?: boolean;
 };
 
 export abstract class StatefulEventSubscriber<State>
@@ -89,6 +90,13 @@ export abstract class StatefulEventSubscriber<State>
     let masterBn: undefined | number = undefined;
     if (options && options.state) {
       this.setState(options.state, blockNumber);
+    } else if (options && options.forceRegenerate) {
+      // ZkEVM forces to always regenerate state when it is old
+      this.logger.debug(
+        `${this.parentName}: ${this.name}: forced to regenerate state`,
+      );
+      const state = await this.generateState(blockNumber);
+      this.setState(state, blockNumber);
     } else {
       if (this.dexHelper.config.isSlave && this.masterPoolNeeded) {
         let stateAsString = await this.dexHelper.cache.hget(

package/tests/constants-e2e.ts

@@ -861,6 +861,28 @@ export const Tokens: {
       decimals: 8,
     },
   },
+  [Network.ZKEVM]: {
+    ETH: {
+      address: ETHER_ADDRESS,
+      decimals: 18,
+    },
+    WETH: {
+      address: '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9',
+      decimals: 18,
+    },
+    MATIC: {
+      address: '0xa2036f0538221a77a3937f1379699f44945018d0',
+      decimals: 18,
+    },
+    WBTC: {
+      address: '0xea034fb02eb1808c2cc3adbc15f447b93cbe08e1',
+      decimals: 8,
+    },
+    USDC: {
+      address: '0xa8ce8aee21bc2a48a5ef670afcc9274c7bbbc035',
+      decimals: 6,
+    },
+  },
 };
 
 export const Holders: {
@@ -1073,6 +1095,13 @@ export const Holders: {
     rETH: '0x4c2e69e58b14de9afedfb94319519ce34e087283',
     WBTC: '0xb9c8f0d3254007ee4b98970b94544e473cd610ec',
   },
+  [Network.ZKEVM]: {
+    ETH: '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9',
+    WETH: '0xc44ad482f24fd750caeba387d2726d8653f8c4bb',
+    MATIC: '0x8f2a1450c040b3c19efe9676165d8f30d8280019',
+    WBTC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
+    USDC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
+  },
 };
 
 export const SmartTokens = Object.keys(Tokens).reduce((acc, _network) => {

package/tests/tenderly-simulation.ts

@@ -1,5 +1,7 @@
+/* eslint-disable no-console */
 import axios from 'axios';
 import { Address } from '@paraswap/core';
+import { Provider } from '@ethersproject/providers';
 import { TxObject } from '../src/types';
 import { StateOverrides, StateSimulateApiOverride } from './smart-tokens';
 
@@ -9,7 +11,50 @@ const TENDERLY_PROJECT = process.env.TENDERLY_PROJECT;
 const TENDERLY_FORK_ID = process.env.TENDERLY_FORK_ID;
 const TENDERLY_FORK_LAST_TX_ID = process.env.TENDERLY_FORK_LAST_TX_ID;
 
-export class TenderlySimulation {
+export type SimulationResult = {
+  success: boolean;
+  gasUsed?: string;
+  url?: string;
+  transaction?: any;
+};
+
+export interface TransactionSimulator {
+  forkId: string;
+  setup(): Promise<void>;
+
+  simulate(
+    params: TxObject,
+    stateOverrides?: StateOverrides,
+  ): Promise<SimulationResult>;
+}
+
+export class EstimateGasSimulation implements TransactionSimulator {
+  forkId: string = '0';
+
+  constructor(private provider: Provider) {}
+
+  async setup() {}
+
+  async simulate(
+    params: TxObject,
+    _: StateOverrides,
+  ): Promise<SimulationResult> {
+    try {
+      const result = await this.provider.estimateGas(params);
+      return {
+        success: true,
+        gasUsed: result.toNumber().toString(),
+      };
+    } catch (e) {
+      console.error(`Estimate gas simulation failed:`, e);
+      return {
+        success: false,
+      };
+    }
+  }
+}
+
+export class TenderlySimulation implements TransactionSimulator {
   lastTx: string = '';
   forkId: string = '';
   maxGasLimit = 80000000;
@@ -118,7 +163,6 @@ export class TenderlySimulation {
       console.error(`TenderlySimulation_simulate:`, e);
       return {
         success: false,
-        tenderlyUrl: '',
       };
     }
   }

package/tests/utils-e2e.ts

@@ -5,7 +5,11 @@ import {
   IParaSwapSDK,
   LocalParaswapSDK,
 } from '../src/implementations/local-paraswap-sdk';
-import { TenderlySimulation } from './tenderly-simulation';
+import {
+  EstimateGasSimulation,
+  TenderlySimulation,
+  TransactionSimulator,
+} from './tenderly-simulation';
 import {
   SwapSide,
   ETHER_ADDRESS,
@@ -24,7 +28,7 @@ import {
 import Erc20ABI from '../src/abi/erc20.json';
 import AugustusABI from '../src/abi/augustus.json';
 import { generateConfig } from '../src/config';
-import { DummyLimitOrderProvider } from '../src/dex-helper';
+import { DummyDexHelper, DummyLimitOrderProvider } from '../src/dex-helper';
 import { constructSimpleSDK, SimpleFetchSDK } from '@paraswap/sdk';
 import axios from 'axios';
 import { SmartToken, StateOverrides } from './smart-tokens';
@@ -268,16 +272,20 @@ export async function testE2E(
   // Specified in BPS: part of 10000
   slippage?: number,
   sleepMs?: number,
+  replaceTenderlyWithEstimateGas?: boolean,
 ) {
   const amount = BigInt(_amount);
-  const ts = new TenderlySimulation(network);
+
+  const ts: TransactionSimulator = replaceTenderlyWithEstimateGas
+    ? new EstimateGasSimulation(new DummyDexHelper(network).provider)
+    : new TenderlySimulation(network);
   await ts.setup();
 
   if (srcToken.address.toLowerCase() !== ETHER_ADDRESS.toLowerCase()) {
     const allowanceTx = await ts.simulate(
       allowTokenTransferProxyParams(srcToken.address, senderAddress, network),
     );
-    if (!allowanceTx.success) console.log(allowanceTx.tenderlyUrl);
+    if (!allowanceTx.success) console.log(allowanceTx.url);
     expect(allowanceTx!.success).toEqual(true);
   }
 
@@ -309,7 +317,7 @@ export async function testE2E(
     expect(deployTx.success).toEqual(true);
 
     const contractAddress =
-      deployTx.transaction.transaction_info.contract_address;
+      deployTx.transaction?.transaction_info.contract_address;
     console.log(
       formatDeployMessage(
         'adapter',
@@ -384,15 +392,15 @@ export async function testE2E(
 
     const swapTx = await ts.simulate(swapParams);
     // Only log gas estimate if testing against API
-    if (useAPI)
+    if (useAPI) {
+      const gasUsed = swapTx.gasUsed || '0';
       console.log(
         `Gas Estimate API: ${priceRoute.gasCost}, Simulated: ${
           swapTx!.gasUsed
-        }, Difference: ${
-          parseInt(priceRoute.gasCost) - parseInt(swapTx!.gasUsed)
-        }`,
+        }, Difference: ${parseInt(priceRoute.gasCost) - parseInt(gasUsed)}`,
       );
-    console.log(`Tenderly URL: ${swapTx!.tenderlyUrl}`);
+    }
+    console.log(`Tenderly URL: ${swapTx!.url}`);
     expect(swapTx!.success).toEqual(true);
   } finally {
     if (paraswap.releaseResources) {

package/build/abi/quickPerps/fast-price-events.json

@@ -1,70 +0,0 @@
-[
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "token",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "internalType": "uint256",
-                "name": "price",
-                "type": "uint256"
-            },
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "priceFeed",
-                "type": "address"
-            }
-        ],
-        "name": "PriceUpdate",
-        "type": "event"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_token", "type": "address" },
-            { "internalType": "uint256", "name": "_price", "type": "uint256" }
-        ],
-        "name": "emitPriceEvent",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "gov",
-        "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "name": "isPriceFeed",
-        "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_gov", "type": "address" }
-        ],
-        "name": "setGov",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_priceFeed", "type": "address" },
-            { "internalType": "bool", "name": "_isPriceFeed", "type": "bool" }
-        ],
-        "name": "setIsPriceFeed",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    }
-]