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

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/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/build/abi/api3-proxy.json

@@ -1,46 +0,0 @@
-[
-    {
-        "inputs": [],
-        "name": "api3ServerV1",
-        "outputs": [
-            {
-                "internalType": "address",
-                "name": "",
-                "type": "address"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "dataFeedId",
-        "outputs": [
-            {
-                "internalType": "bytes32",
-                "name": "",
-                "type": "bytes32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "read",
-        "outputs": [
-            {
-                "internalType": "int224",
-                "name": "value",
-                "type": "int224"
-            },
-            {
-                "internalType": "uint32",
-                "name": "timestamp",
-                "type": "uint32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    }
-]