@paraswap/dex-lib 4.1.7-pub-sub → 4.1.7-pub-sub.3

package/src/dex/weth/weth-gas-estimation.test.ts

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+import { ethers } from 'ethers';
+
+describe('Weth Gas Estimation', () => {
+  const dexKey = 'Weth';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const ETH = Tokens[network]['ETH'];
+    const WETH = Tokens[network]['WETH'];
+    const amount = ethers.utils.parseEther('1').toBigInt();
+
+    it('wrap', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        WETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+
+    it('unwrap', async () => {
+      await testGasEstimation(
+        network,
+        WETH,
+        ETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/weth/weth.ts

@@ -94,11 +94,13 @@ export class Weth
 
     if (!isWETHSwap) return null;
 
+    const gasCost = isETHAddress(srcToken.address) ? 6_500 : 9000;
+
     return [
       {
         prices: amounts,
         unit: this.unitPrice,
-        gasCost: this.poolGasCost,
+        gasCost,
         exchange: this.dexKey,
         poolAddresses: [this.address],
         data: null,

package/src/dex/wombat/wombat-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Wombat Gas Estimation', () => {
+  const dexKey = 'Wombat';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swapExactTokensForTokens', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/wsteth/wsteth-gas-estimation.test.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('wstETH Gas Estimation', () => {
+  const dexKey = 'wstETH';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const wstETH = Tokens[network]['wstETH'];
+    const amount = 1000000000000000000n;
+
+    it('wrap', async () => {
+      await testGasEstimation(
+        network,
+        STETH,
+        wstETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+
+    it('unwrap', async () => {
+      await testGasEstimation(
+        network,
+        wstETH,
+        STETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/wusdm/wusdm-gas-estimation.test.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('wUSDM Gas Estimation', () => {
+  const dexKey = 'wUSDM';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const wUSDM = Tokens[network]['wUSDM'];
+    const USDM = Tokens[network]['USDM'];
+    const amount = 500n;
+
+    it('deposit', async () => {
+      await testGasEstimation(
+        network,
+        USDM,
+        wUSDM,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+
+    it('redeem', async () => {
+      await testGasEstimation(
+        network,
+        wUSDM,
+        USDM,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/lib/pub-sub.ts

@@ -37,7 +37,9 @@ export class ExpKeyValuePubSub {
 
     this.dexHelper.cache.subscribe(this.channel, (_, msg) => {
       const decodedMsg = JSON.parse(msg) as KeyValuePubSubMsg;
-      this.logger.info(`${this.logPrefix} Received msg: '${msg}'`);
+      this.logger.info(
+        `${this.logPrefix} Received msg: '${Object.keys(decodedMsg).length}'`,
+      );
       this.handleSubscription(decodedMsg);
     });
   }
@@ -47,7 +49,7 @@ export class ExpKeyValuePubSub {
     this.logger.info(
       `${this.logPrefix} Publishing msg: '${JSON.stringify({
         expiresAt,
-        data,
+        data: Object.keys(data).length,
       })}'`,
     );
     this.dexHelper.cache.publish(
@@ -82,7 +84,9 @@ export class ExpKeyValuePubSub {
     const localValue = this.localCache.get<T>(key);
 
     this.logger.info(
-      `${this.logPrefix} Getting and caching key: ${key}, localValue: ${localValue}`,
+      `${this.logPrefix} Getting and caching key: ${key}, localValue length: ${
+        localValue ? Object.keys(localValue).length : 0
+      }`,
     );
 
     if (localValue) {
@@ -309,7 +313,7 @@ export class NonExpSetPubSub {
     this.dexHelper.cache.subscribe(this.channel, (_, msg) => {
       const decodedMsg = JSON.parse(msg) as SetPubSubMsg;
       this.logger.info(
-        `${this.logPrefix} Received subscription msg: '${decodedMsg}'`,
+        `${this.logPrefix} Received subscription msg: '${decodedMsg.length}'`,
       );
       this.handleSubscription(decodedMsg);
     });
@@ -317,7 +321,7 @@ export class NonExpSetPubSub {
 
   publish(msg: SetPubSubMsg) {
     if (msg.length > 0) {
-      this.logger.info(`${this.logPrefix} Publishing msg: '${msg}'`);
+      this.logger.info(`${this.logPrefix} Publishing msg: '${msg.length}'`);
       this.dexHelper.cache.publish(this.channel, JSON.stringify(msg));
     }
   }

package/src/pricing-helper.ts

@@ -191,7 +191,7 @@ export class PricingHelper {
       srcDexFee: 0,
       destDexFee: 0,
     },
-    rollupL1ToL2GasRatio?: number,
+    rollupL1CalldataCostToL2GasCost?: (calldataCost: number) => number,
   ): Promise<PoolPrices<any>[]> {
     const dexPoolPrices = await Promise.all(
       dexKeys.map(async key => {
@@ -229,39 +229,47 @@ export class PricingHelper {
                 )
                 .then(poolPrices => {
                   try {
-                    if (!poolPrices || !rollupL1ToL2GasRatio) {
+                    if (!poolPrices || !rollupL1CalldataCostToL2GasCost) {
                       return resolve(poolPrices);
                     }
                     return resolve(
                       poolPrices.map(pp => {
                         pp.gasCostL2 = pp.gasCost;
-                        const gasCostL1 = dexInstance.getCalldataGasCost(pp);
+                        const calldataGasCost =
+                          dexInstance.getCalldataGasCost(pp);
                         if (
                           typeof pp.gasCost === 'number' &&
-                          typeof gasCostL1 === 'number'
+                          pp.gasCost !== 0 &&
+                          typeof calldataGasCost === 'number'
                         ) {
                           pp.gasCost += Math.ceil(
-                            rollupL1ToL2GasRatio * gasCostL1,
+                            rollupL1CalldataCostToL2GasCost(calldataGasCost),
                           );
                         } else if (
                           typeof pp.gasCost !== 'number' &&
-                          typeof gasCostL1 !== 'number'
+                          typeof calldataGasCost !== 'number'
                         ) {
-                          if (pp.gasCost.length !== gasCostL1.length) {
+                          if (pp.gasCost.length !== calldataGasCost.length) {
                             throw new Error(
                               `getCalldataGasCost returned wrong array length in dex ${key}`,
                             );
                           }
-                          pp.gasCost = pp.gasCost.map(
-                            (g, i) =>
-                              g +
-                              Math.ceil(rollupL1ToL2GasRatio * gasCostL1[i]),
+                          pp.gasCost = pp.gasCost.map((g, i) =>
+                            g === 0
+                              ? 0
+                              : g +
+                                Math.ceil(
+                                  rollupL1CalldataCostToL2GasCost(
+                                    calldataGasCost[i],
+                                  ),
+                                ),
                           );
                         } else {
                           throw new Error(
                             `getCalldataGasCost returned wrong type in dex ${key}`,
                           );
                         }
+                        pp.calldataGasCost = calldataGasCost;
                         return pp;
                       }),
                     );

package/src/types.ts

@@ -227,6 +227,7 @@ export type PoolPrices<T> = {
   exchange: string;
   gasCost: number | number[];
   gasCostL2?: number | number[];
+  calldataGasCost?: number | number[];
   poolAddresses?: Array<Address>;
 };
 

package/tests/constants-e2e.ts

@@ -591,6 +591,14 @@ export const Tokens: {
       decimals: 6,
       symbol: 'USUALM',
     },
+    stataEthWETH: {
+      address: '0x252231882FB38481497f3C767469106297c8d93b',
+      decimals: 18,
+    },
+    waEthWETH: {
+      address: '0x0bfc9d54Fc184518A81162F8fB99c2eACa081202',
+      decimals: 18,
+    },
   },
   [Network.POLYGON]: {
     jGBP: {

package/tests/tenderly-simulation-new.test.ts

@@ -0,0 +1,151 @@
+import { ethers } from 'ethers';
+import { TenderlySimulatorNew } from './tenderly-simulation-new';
+
+describe('Tenderly', () => {
+  const tenderly = TenderlySimulatorNew.getInstance();
+  const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+  const USDT = '0xdac17f958d2ee523a2206206994597c13d831ec7';
+  const account = '0x89f53c184ed91cd333fdec0eceeddcaea0cc28cf';
+  const spender = '0x6a000f20005980200259b80c5102003040001068';
+
+  describe('calculateAddressBalanceSlot', () => {
+    it('should calculate account balance storage slot', () => {
+      const balanceOfSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [9]); // usdc's `balanceOf` mapping slot
+      // https://dashboard.tenderly.co/paraswap/paraswap/simulator/d7964910-d8ce-446b-a347-c4f1da1acead/debugger?trace=0.2.0.0
+      const expected =
+        '0x8cef03c2b7574a38d9a9e8dd69980240d41d70485643f407de33055936c48f97';
+      const calculated = tenderly.calculateAddressBalanceSlot(
+        balanceOfSlot,
+        account,
+      );
+      // assert
+      expect(calculated).toEqual(expected);
+    });
+  });
+
+  describe('calculateAddressAllowanceSlots', () => {
+    it('should calculate account balance storage slot', () => {
+      const allowanceSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [10]); // usdc's `allowance` mapping slot
+      // https://dashboard.tenderly.co/paraswap/paraswap/simulator/e2a6cad1-4a82-4ba7-8c3e-ef097315542c/debugger?trace=0.2.0
+      const expected =
+        '0x371a34ab690ce2826b137a25bfdaf43d0b93c819878de2df8877f1fb50ffb206';
+      const calculated = tenderly.calculateAddressAllowanceSlot(
+        allowanceSlot,
+        account,
+        spender,
+      );
+      // assert
+      expect(calculated).toEqual(expected);
+    });
+  });
+
+  describe('buildBalanceOfSimulationRequest', () => {
+    it('should build `balanceOf` simulation request', () => {
+      const request = tenderly.buildBalanceOfSimulationRequest(
+        1,
+        USDC,
+        account,
+      );
+
+      const expectedCallData = ethers.utils.hexConcat([
+        '0x70a08231', // selector
+        ethers.utils.defaultAbiCoder.encode(['address'], [account]),
+      ]);
+
+      expect(request.data).toEqual(expectedCallData);
+    });
+  });
+
+  describe('buildAllowanceSimulationRequest', () => {
+    it('should build `allowance` simulation request', () => {
+      const request = tenderly.buildAllowanceSimulationRequest(
+        1,
+        USDC,
+        account,
+        spender,
+      );
+
+      const expectedCallData = ethers.utils.hexConcat([
+        '0xdd62ed3e', // selector
+        ethers.utils.defaultAbiCoder.encode(
+          ['address', 'address'],
+          [account, spender],
+        ),
+      ]);
+      // assert
+      expect(request.data).toEqual(expectedCallData);
+    });
+  });
+
+  describe('findTokenBalanceOfSlot', () => {
+    it('should find Mainnet USDC `balanceOf` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [9]);
+      const foundSlot = await tenderly.findTokenBalanceOfSlot(1, USDC);
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet USDT `balanceOf` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [2]);
+      const foundSlot = await tenderly.findTokenBalanceOfSlot(1, USDT);
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet stETH `balanceOf` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [0]);
+      const foundSlot = await tenderly.findTokenBalanceOfSlot(
+        1,
+        '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84', // Lido's `stETH`
+      );
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet aEthDai `balanceOf` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [52]);
+      const foundSlot = await tenderly.findTokenBalanceOfSlot(
+        1,
+        '0x018008bfb33d285247A21d44E50697654f754e63', // Aave's `aEthDai`
+      );
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+  });
+
+  describe('findTokenAllowanceSlot', () => {
+    it('should find Mainnet USDC `allowance` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [10]);
+      const foundSlot = await tenderly.findTokenAllowanceSlot(1, USDC);
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet USDT `allowance` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [5]);
+      const foundSlot = await tenderly.findTokenAllowanceSlot(1, USDT);
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet stETH `allowance` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [1]);
+      const foundSlot = await tenderly.findTokenAllowanceSlot(
+        1,
+        '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84', // Lido's `stETH`
+      );
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+
+    it('should find Mainnet aEthDai `allowance` storage slot', async () => {
+      const expectedSlot = ethers.utils.defaultAbiCoder.encode(['uint'], [53]);
+      const foundSlot = await tenderly.findTokenAllowanceSlot(
+        1,
+        '0x018008bfb33d285247A21d44E50697654f754e63', // Aave's `aEthDai`
+      );
+      // assert
+      expect(foundSlot.slot).toEqual(expectedSlot);
+    });
+  });
+});