@paraswap/dex-lib 2.37.0 → 2.37.2-current-fee-ramses-v2

package/src/dex/hashflow/hashflow.ts

@@ -62,6 +62,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   readonly isStatePollingDex = true;
   readonly hasConstantPriceLargeAmounts = false;
   readonly needWrapNative = false;
+  readonly needsSequentialPreprocessing = true;
   readonly isFeeOnTransferSupported = false;
   private api: HashflowApi;
   private rateFetcher: RateFetcher;
@@ -737,7 +738,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         );
         await this.setBlacklist(options.txOrigin);
       } else {
-        if(e instanceof TooStrictSlippageCheckError) {
+        if (e instanceof TooStrictSlippageCheckError) {
           this.logger.warn(
             `${this.dexKey}-${this.network}: Market Maker ${mm} failed to build transaction on side ${side} with too strict slippage. Skipping restriction`,
           );

package/src/dex/idex.ts

@@ -20,6 +20,7 @@ import { IDexHelper } from '../dex-helper/idex-helper';
 
 export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
   needWrapNative: boolean;
+  needsSequentialPreprocessing?: boolean;
 
   // Returns the ETH fee required to swap
   // It is optional for a DEX to implement this

package/src/dex/index.ts

@@ -315,4 +315,10 @@ export class DexAdapterService {
       ? this.sellAdapters[specialDexKey]
       : this.buyAdapters[specialDexKey];
   }
+
+  doesPreProcessingRequireSequentiality(dexKey: string): boolean {
+    const dex = this.getDexByKey(dexKey);
+
+    return !!dex.needsSequentialPreprocessing;
+  }
 }

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

@@ -5,6 +5,7 @@ import { Address } from '../../types';
 import RamsesV2StateMulticallABI from '../../abi/RamsesV2StateMulticall.abi.json';
 import { AbiItem } from 'web3-utils';
 import { decodeStateMultiCallResultWithRelativeBitmaps } from './forks/ramses-v2/utils';
+import { RamsesV2EventPool } from './forks/ramses-v2/ramses-v2-pool';
 
 const SUPPORTED_FEES = [10000n, 3000n, 500n, 100n];
 
@@ -251,6 +252,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
       initRetryFrequency: 10,
+      eventPoolImplementation: RamsesV2EventPool,
       decodeStateMultiCallResultWithRelativeBitmaps,
       initHash:
         '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
@@ -273,7 +275,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/44554/uniswap-v3/version/latest',
     },
   },
-  'Retro': {
+  Retro: {
     [Network.POLYGON]: {
       factory: '0x91e1B99072f238352f59e58de875691e20Dc19c1',
       quoter: '0xfe08be075758935cb6cb9318d1fbb60920416d4e',
@@ -284,8 +286,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       chunksCount: 10,
       initRetryFrequency: 10,
       initHash: `0x817e07951f93017a93327ac8cc31e946540203a19e1ecc37bc1761965c2d1090`,
-      subgraphURL:
-        'https://api.thegraph.com/subgraphs/name/ruvlol/univ3-test',
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/ruvlol/univ3-test',
     },
   },
 };

package/src/dex/uniswap-v3/forks/ramses-v2/ramses-v2-pool.ts

@@ -0,0 +1,102 @@
+import { UniswapV3EventPool } from '../../uniswap-v3-pool';
+import { DecodedStateMultiCallResultWithRelativeBitmaps, PoolState } from '../../types';
+import { assert } from 'ts-essentials';
+import { _reduceTickBitmap, _reduceTicks } from '../../contract-math/utils';
+import { bigIntify } from '../../../../utils';
+import { TickBitMap } from '../../contract-math/TickBitMap';
+import { uint24ToBigInt } from '../../../../lib/decoders';
+import { Interface } from 'ethers/lib/utils';
+import RamsesV2PoolABI from '../../../../abi/ramses-v2/RamsesV2Pool.abi.json';
+
+export class RamsesV2EventPool extends UniswapV3EventPool {
+
+  public readonly poolIface = new Interface(RamsesV2PoolABI);
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+    const callData = this._getStateRequestCallData();
+
+    const calldataWithFee = [
+      ...callData,
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('currentFee'),
+        decodeFunction: uint24ToBigInt,
+      },
+    ];
+
+    const [resBalance0, resBalance1, resState, resCurrentFee] =
+      await this.dexHelper.multiWrapper.tryAggregate<
+        bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+        >(
+        false,
+        calldataWithFee,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+
+    assert(resState.success, 'Pool does not exist');
+
+    const [balance0, balance1, _state, fee] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      resState.returnData,
+      resCurrentFee.returnData,
+    ] as [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmaps, bigint];
+
+    const tickBitmap = {};
+    const ticks = {};
+
+    _reduceTickBitmap(tickBitmap, _state.tickBitmap);
+    _reduceTicks(ticks, _state.ticks);
+
+    const observations = {
+      [_state.slot0.observationIndex]: {
+        blockTimestamp: bigIntify(_state.observation.blockTimestamp),
+        tickCumulative: bigIntify(_state.observation.tickCumulative),
+        secondsPerLiquidityCumulativeX128: bigIntify(
+          _state.observation.secondsPerLiquidityCumulativeX128,
+        ),
+        initialized: _state.observation.initialized,
+      },
+    };
+
+    const currentTick = bigIntify(_state.slot0.tick);
+    const tickSpacing = bigIntify(_state.tickSpacing);
+
+    const startTickBitmap = TickBitMap.position(currentTick / tickSpacing)[0];
+    const requestedRange = this.getBitmapRangeToRequest();
+
+    return {
+      pool: _state.pool,
+      blockTimestamp: bigIntify(_state.blockTimestamp),
+      slot0: {
+        sqrtPriceX96: bigIntify(_state.slot0.sqrtPriceX96),
+        tick: currentTick,
+        observationIndex: +_state.slot0.observationIndex,
+        observationCardinality: +_state.slot0.observationCardinality,
+        observationCardinalityNext: +_state.slot0.observationCardinalityNext,
+        feeProtocol: bigIntify(_state.slot0.feeProtocol),
+      },
+      liquidity: bigIntify(_state.liquidity),
+      fee,
+      tickSpacing,
+      maxLiquidityPerTick: bigIntify(_state.maxLiquidityPerTick),
+      tickBitmap,
+      ticks,
+      observations,
+      isValid: true,
+      startTickBitmap,
+      lowestKnownTick:
+        (BigInt.asIntN(24, startTickBitmap - requestedRange) << 8n) *
+        tickSpacing,
+      highestKnownTick:
+        ((BigInt.asIntN(24, startTickBitmap + requestedRange) << 8n) +
+          BigInt.asIntN(24, 255n)) *
+        tickSpacing,
+      balance0,
+      balance1,
+    };
+  }
+
+}

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

@@ -3,6 +3,7 @@ import { NumberAsString } from '../../types';
 import { Address } from '../../types';
 import { AbiItem } from 'web3-utils';
 import { MultiResult } from '../../lib/multi-wrapper';
+import { UniswapV3EventPool } from './uniswap-v3-pool';
 
 export type OracleObservation = {
   blockTimestamp: bigint;
@@ -79,6 +80,7 @@ export type DexParams = {
   subgraphURL: string;
   initHash: string;
   stateMultiCallAbi?: AbiItem[];
+  eventPoolImplementation?: typeof UniswapV3EventPool;
   decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
 };
 

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

@@ -1101,7 +1101,6 @@ describe('SushiSwapV3', () => {
   });
 });
 
-
 describe('Retro', () => {
   const dexKey = 'Retro';
 
@@ -1233,14 +1232,10 @@ describe('Retro', () => {
     });
 
     it('getTopPoolsForToken', async function () {
-      const poolLiquidity = await retro.getTopPoolsForToken(
-        TokenB.address,
-        10,
-      );
+      const poolLiquidity = await retro.getTopPoolsForToken(TokenB.address, 10);
       console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
 
       checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
     });
   });
-
 });

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

@@ -199,7 +199,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return null; // ignore unrecognized event
   }
 
-  private _getStateRequestCallData() {
+  protected _getStateRequestCallData() {
     if (!this._stateRequestCallData) {
       const callData: MultiCallParams<
         bigint | DecodedStateMultiCallResultWithRelativeBitmaps

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

@@ -242,25 +242,29 @@ export class UniswapV3
     }
 
     this.logger.trace(`starting to listen to new pool: ${key}`);
+    const poolImplementation =
+      this.config.eventPoolImplementation !== undefined
+        ? this.config.eventPoolImplementation
+        : UniswapV3EventPool;
     pool =
       pool ||
-      new UniswapV3EventPool(
-        this.dexHelper,
-        this.dexKey,
-        this.stateMultiContract,
-        this.config.decodeStateMultiCallResultWithRelativeBitmaps,
-        this.erc20Interface,
-        this.config.factory,
-        fee,
-        token0,
-        token1,
-        this.logger,
-        this.cacheStateKey,
-        this.config.initHash,
+      new poolImplementation(
+          this.dexHelper,
+          this.dexKey,
+          this.stateMultiContract,
+          this.config.decodeStateMultiCallResultWithRelativeBitmaps,
+          this.erc20Interface,
+          this.config.factory,
+          fee,
+          token0,
+          token1,
+          this.logger,
+          this.cacheStateKey,
+          this.config.initHash,
       );
 
     try {
-      await pool.initialize(blockNumber, {
+      await pool!.initialize(blockNumber, {
         initCallback: (state: DeepReadonly<PoolState>) => {
           //really hacky, we need to push poolAddress so that we subscribeToLogs in StatefulEventSubscriber
           pool!.addressesSubscribed[0] = state.pool;
@@ -289,10 +293,10 @@ export class UniswapV3
         // on unknown error mark as failed and increase retryCount for retry init strategy
         // note: state would be null by default which allows to fallback
         this.logger.warn(
-          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}, fee=${fee} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
+          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}, fee=${fee} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool!.initRetryAttemptCount}`,
           e,
         );
-        pool.initFailed = true;
+        pool!.initFailed = true;
       }
     }
 
@@ -309,8 +313,8 @@ export class UniswapV3
     }
 
     this.eventPools[this.getPoolIdentifier(srcAddress, destAddress, fee)] =
-      pool;
-    return pool;
+      pool!;
+    return pool!;
   }
 
   async addMasterPool(poolKey: string, blockNumber: number): Promise<boolean> {
@@ -1066,6 +1070,7 @@ export class UniswapV3
       initHash: this.config.initHash,
       subgraphURL: this.config.subgraphURL,
       stateMultiCallAbi: this.config.stateMultiCallAbi,
+      eventPoolImplementation: this.config.eventPoolImplementation,
       decodeStateMultiCallResultWithRelativeBitmaps:
         this.config.decodeStateMultiCallResultWithRelativeBitmaps,
     };