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

package/src/dex/algebra/algebra-factory.ts

@@ -0,0 +1,70 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/algebra/AlgebraFactory-v1_1.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from './types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+}: {
+  token0: string;
+  token1: string;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class AlgebraFactory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['Pool'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0;
+    const token1 = event.args.token1;
+
+    await this.onPoolCreated({ token0, token1 });
+  }
+}

package/src/dex/algebra/algebra.ts

@@ -38,14 +38,15 @@ import {
 import { AlgebraMath } from './lib/AlgebraMath';
 import { AlgebraEventPoolV1_1 } from './algebra-pool-v1_1';
 import { AlgebraEventPoolV1_9 } from './algebra-pool-v1_9';
+import { AlgebraFactory, OnPoolCreatedCallback } from './algebra-factory';
 
 type PoolPairsInfo = {
   token0: Address;
   token1: Address;
 };
 
-const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 60 * 60 * 1000; // 3 hours
-const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const ALGEBRA_EFFICIENCY_FACTOR = 3;
 const ALGEBRA_TICK_GAS_COST = 24_000; // Ceiled
 const ALGEBRA_TICK_BASE_OVERHEAD = 75_000;
@@ -59,6 +60,7 @@ const MAX_STALE_STATE_BLOCK_AGE = {
 type IAlgebraEventPool = AlgebraEventPoolV1_1 | AlgebraEventPoolV1_9;
 
 export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
+  private readonly factory: AlgebraFactory;
   readonly isFeeOnTransferSupported: boolean = false;
   protected eventPools: Record<string, IAlgebraEventPool | null> = {};
 
@@ -114,6 +116,14 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
 
     this.AlgebraPoolImplem =
       config.version === 'v1.1' ? AlgebraEventPoolV1_1 : AlgebraEventPoolV1_9;
+
+    this.factory = new AlgebraFactory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet,
+    );
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
@@ -126,13 +136,13 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
   }
 
   async initializePricing(blockNumber: number) {
-    const cleanNonExistingPoolTTLMs =
-      this.config.cleanExistingPoolTTLMs ||
-      ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
 
     if (!this.dexHelper.config.isSlave) {
       const cleanExpiredNotExistingPoolsKeys = async () => {
-        const maxTimestamp = Date.now() - cleanNonExistingPoolTTLMs;
+        const maxTimestamp =
+          Date.now() - ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
         await this.dexHelper.cache.zremrangebyscore(
           this.notExistingPoolSetKey,
           0,
@@ -147,6 +157,37 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     }
   }
 
+  /*
+   * When a non existing pool is queried, it's blacklisted for an arbitrary long period in order to prevent issuing too many rpc calls
+   * Once the pool is created, it gets immediately flagged
+   */
+  onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback = async ({
+    token0,
+    token1,
+  }) => {
+    const logPrefix = '[Algebra.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${token0}_${token1}`.toLowerCase();
+
+    // consider doing it only from master pool for less calls to distant cache
+
+    // delete entry locally to let local instance discover the pool
+    delete this.eventPools[this.getPoolIdentifier(_token0, _token1)];
+
+    try {
+      this.logger.info(
+        `${logPrefix} delete pool from not existing set: ${poolKey}`,
+      );
+      // delete pool record from set
+      await this.dexHelper.cache.zrem(this.notExistingPoolSetKey, [poolKey]);
+    } catch (error) {
+      this.logger.error(
+        `${logPrefix} failed to delete pool from set: ${poolKey}`,
+        error,
+      );
+    }
+  };
+
   async getPool(
     srcAddress: Address,
     destAddress: Address,

package/src/dex/algebra/config.ts

@@ -83,7 +83,6 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       deployer: '0x6dd3fb9653b10e806650f107c3b5a0a6ff974f65',
       version: 'v1.9',
-      cleanExistingPoolTTLMs: 20 * 60 * 1000,
     },
   },
 };

package/src/dex/algebra/types.ts

@@ -51,6 +51,8 @@ export type PoolState_v1_9 = {
   areTicksCompressed: boolean;
 };
 
+export type FactoryState = Record<string, never>;
+
 export type AlgebraData = {
   path: {
     tokenIn: Address;
@@ -73,7 +75,6 @@ export type DexParams = {
   version: 'v1.1' | 'v1.9';
   forceRPC?: boolean;
   forceManualStateGenerate?: boolean;
-  cleanExistingPoolTTLMs?: number;
 };
 
 export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;

package/src/dex/pancakeswap-v3/pancakeswap-v3-factory.ts

@@ -0,0 +1,73 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/pancakeswap-v3/PancakeswapV3Factory.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from '../uniswap-v3/types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+  fee,
+}: {
+  token0: string;
+  token1: string;
+  fee: bigint;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class PancakeswapV3Factory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['PoolCreated'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0;
+    const token1 = event.args.token1;
+    const fee = event.args.fee;
+
+    await this.onPoolCreated({ token0, token1, fee });
+  }
+}

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

@@ -56,6 +56,10 @@ import {
   DEFAULT_ID_ERC20,
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
+import {
+  OnPoolCreatedCallback,
+  PancakeswapV3Factory,
+} from './pancakeswap-v3-factory';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -63,14 +67,15 @@ type PoolPairsInfo = {
   fee: string;
 };
 
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 60 * 60 * 24 * 1000; // 24 hours
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class PancakeswapV3
   extends SimpleExchange
   implements IDex<UniswapV3Data>
 {
+  private readonly factory: PancakeswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, PancakeSwapV3EventPool | null> = {};
 
@@ -117,6 +122,14 @@ export class PancakeswapV3
 
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
+
+    this.factory = new PancakeswapV3Factory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet,
+    );
   }
 
   get supportedFees() {
@@ -133,6 +146,9 @@ export class PancakeswapV3
   }
 
   async initializePricing(blockNumber: number) {
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
+
     if (!this.dexHelper.config.isSlave) {
       const cleanExpiredNotExistingPoolsKeys = async () => {
         const maxTimestamp =
@@ -151,6 +167,38 @@ export class PancakeswapV3
     }
   }
 
+  /*
+   * When a non existing pool is queried, it's blacklisted for an arbitrary long period in order to prevent issuing too many rpc calls
+   * Once the pool is created, it gets immediately flagged
+   */
+  onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback = async ({
+    token0,
+    token1,
+    fee,
+  }) => {
+    const logPrefix = '[PancakeV3.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${token0}_${token1}_${fee}`.toLowerCase();
+
+    // consider doing it only from master pool for less calls to distant cache
+
+    // delete entry locally to let local instance discover the pool
+    delete this.eventPools[this.getPoolIdentifier(_token0, _token1, fee)];
+
+    try {
+      this.logger.info(
+        `${logPrefix} delete pool from not existing set: ${poolKey}`,
+      );
+      // delete pool record from set
+      await this.dexHelper.cache.zrem(this.notExistingPoolSetKey, [poolKey]);
+    } catch (error) {
+      this.logger.error(
+        `${logPrefix} failed to delete pool from set :${poolKey}`,
+        error,
+      );
+    }
+  };
+
   async getPool(
     srcAddress: Address,
     destAddress: Address,

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,104 @@
+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];
+
+    const tickBitmap = {};
+    const ticks = {};
+
+    this.currentFeeCodeAsString = fee.toString();
+    _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;
@@ -53,6 +54,8 @@ export type PoolState = {
   balance1: bigint;
 };
 
+export type FactoryState = Record<string, never>;
+
 export type UniswapV3Data = {
   path: {
     tokenIn: Address;
@@ -79,6 +82,7 @@ export type DexParams = {
   subgraphURL: string;
   initHash: string;
   stateMultiCallAbi?: AbiItem[];
+  eventPoolImplementation?: typeof UniswapV3EventPool;
   decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
 };
 

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

@@ -0,0 +1,73 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/uniswap-v3/UniswapV3Factory.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from './types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+  fee,
+}: {
+  token0: string;
+  token1: string;
+  fee: bigint;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class UniswapV3Factory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['PoolCreated'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0;
+    const token1 = event.args.token1;
+    const fee = event.args.fee;
+
+    await this.onPoolCreated({ token0, token1, fee });
+  }
+}

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

@@ -46,7 +46,9 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
 
   private _poolAddress?: Address;
 
-  private _stateRequestCallData?: MultiCallParams<
+  public currentFeeCodeAsString: string | undefined;
+
+  protected _stateRequestCallData?: MultiCallParams<
     bigint | DecodedStateMultiCallResultWithRelativeBitmaps
   >[];
 
@@ -55,7 +57,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
   public initFailed = false;
   public initRetryAttemptCount = 0;
 
-  public readonly feeCodeAsString;
+  public feeCodeAsString;
 
   constructor(
     readonly dexHelper: IDexHelper,
@@ -66,7 +68,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 +201,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return null; // ignore unrecognized event
   }
 
-  private _getStateRequestCallData() {
+  protected _getStateRequestCallData() {
     if (!this._stateRequestCallData) {
       const callData: MultiCallParams<
         bigint | DecodedStateMultiCallResultWithRelativeBitmaps