@paraswap/dex-lib 2.37.1 → 2.37.2-current-fee-ramses-v2.2

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',

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

@@ -0,0 +1,105 @@
+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,
+      },
+    ];
+
+    this._stateRequestCallData = calldataWithFee;
+
+    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];
+
+    this.feeCode = fee;
+    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: this.feeCode,
+      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-pool.ts

@@ -46,7 +46,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
 
   private _poolAddress?: Address;
 
-  private _stateRequestCallData?: MultiCallParams<
+  protected _stateRequestCallData?: MultiCallParams<
     bigint | DecodedStateMultiCallResultWithRelativeBitmaps
   >[];
 
@@ -66,7 +66,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
       | undefined,
     readonly erc20Interface: Interface,
     protected readonly factoryAddress: Address,
-    public readonly feeCode: bigint,
+    public feeCode: bigint,
     token0: Address,
     token1: Address,
     logger: Logger,
@@ -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,
     };