@paraswap/dex-lib 2.34.0 → 2.35.0

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/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) {