@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.5

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

@@ -72,15 +72,14 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     logger: Logger,
     mapKey: string = '',
     readonly poolInitCodeHash: string,
+    public readonly tickSpacing?: bigint,
   ) {
-    super(
-      parentName,
-      `${token0}_${token1}_${feeCode}`,
-      dexHelper,
-      logger,
-      true,
-      mapKey,
-    );
+    let poolKey = `${token0}_${token1}_${feeCode}`;
+    if (tickSpacing !== undefined) {
+      poolKey = `${poolKey}_${tickSpacing}`;
+    }
+
+    super(parentName, poolKey, dexHelper, logger, true, mapKey);
     this.feeCodeAsString = feeCode.toString();
     this.token0 = token0.toLowerCase();
     this.token1 = token1.toLowerCase();
@@ -124,6 +123,15 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     await super.initialize(blockNumber, options);
   }
 
+  protected getPoolIdentifierData() {
+    return {
+      token0: this.token0,
+      token1: this.token1,
+      fee: this.feeCode,
+      tickSpacing: this.tickSpacing,
+    };
+  }
+
   protected async processBlockLogs(
     state: DeepReadonly<PoolState>,
     logs: Readonly<Log>[],
@@ -495,7 +503,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return pool;
   }
 
-  private _computePoolAddress(
+  protected _computePoolAddress(
     token0: Address,
     token1: Address,
     fee: bigint,

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

@@ -71,22 +71,27 @@ import {
 import { OptimalSwapExchange } from '@paraswap/core';
 import { OnPoolCreatedCallback, UniswapV3Factory } from './uniswap-v3-factory';
 import { hexConcat, hexlify, hexZeroPad, hexValue } from 'ethers/lib/utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 type PoolPairsInfo = {
   token0: Address;
   token1: Address;
   fee: string;
+  tickSpacing?: string;
 };
 
-const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
-const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
-const UNISWAPV3_QUOTE_GASLIMIT = 200_000;
+export const PoolsRegistryHashKey = `${CACHE_PREFIX}_poolsRegistry`;
+
+export const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+export const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS =
+  24 * 60 * 60 * 1000; // Once in a day
+export const UNISWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class UniswapV3
   extends SimpleExchange
   implements IDex<UniswapV3Data, UniswapV3Param | UniswapV3ParamsDirect>
 {
-  private readonly factory: UniswapV3Factory;
+  protected readonly factory: UniswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, UniswapV3EventPool | null> = {};
 
@@ -103,19 +108,22 @@ export class UniswapV3
         'UniswapV3',
         'SushiSwapV3',
         'QuickSwapV3.1',
+        'SpookySwapV3',
         'RamsesV2',
         'ChronosV3',
         'Retro',
         'BaseswapV3',
+        'PharaohV2',
+        'AlienBaseV3',
       ]),
     );
 
   logger: Logger;
 
   private uniswapMulti: Contract;
-  private stateMultiContract: Contract;
+  protected stateMultiContract: Contract;
 
-  private notExistingPoolSetKey: string;
+  protected notExistingPoolSetKey: string;
 
   constructor(
     protected network: Network,
@@ -149,13 +157,7 @@ export class UniswapV3
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
 
-    this.factory = new UniswapV3Factory(
-      dexHelper,
-      dexKey,
-      this.config.factory,
-      this.logger,
-      this.onPoolCreatedDeleteFromNonExistingSet,
-    );
+    this.factory = this.getFactoryInstance();
   }
 
   get supportedFees() {
@@ -166,8 +168,18 @@ export class UniswapV3
     return this.adapters[side] ? this.adapters[side] : null;
   }
 
-  getPoolIdentifier(srcAddress: Address, destAddress: Address, fee: bigint) {
+  getPoolIdentifier(
+    srcAddress: Address,
+    destAddress: Address,
+    fee: bigint,
+    tickSpacing?: bigint,
+  ) {
     const tokenAddresses = this._sortTokens(srcAddress, destAddress).join('_');
+
+    if (tickSpacing) {
+      return `${this.dexKey}_${tokenAddresses}_${fee}_${tickSpacing}`;
+    }
+
     return `${this.dexKey}_${tokenAddresses}_${fee}`;
   }
 
@@ -209,48 +221,47 @@ export class UniswapV3
    * 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 = '[onPoolCreatedDeleteFromNonExistingSet]';
-    const [_token0, _token1] = this._sortTokens(token0, token1);
-    const poolKey = `${_token0}_${_token1}_${fee}`;
+  protected onPoolCreatedDeleteFromNonExistingSet(): OnPoolCreatedCallback {
+    return async ({ token0, token1, fee }) => {
+      const logPrefix = '[onPoolCreatedDeleteFromNonExistingSet]';
+      const [_token0, _token1] = this._sortTokens(token0, token1);
+      const poolKey = `${_token0}_${_token1}_${fee}`;
 
-    // consider doing it only from master pool for less calls to distant cache
+      // 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)];
+      // 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=${this.notExistingPoolSetKey}; key=${poolKey}`,
-      );
-      // delete pool record from set
-      const result = await this.dexHelper.cache.zrem(
-        this.notExistingPoolSetKey,
-        [poolKey],
-      );
-      this.logger.info(
-        `${logPrefix} delete pool from not existing set=${this.notExistingPoolSetKey}; key=${poolKey}; result: ${result}`,
-      );
-    } catch (error) {
-      this.logger.error(
-        `${logPrefix} ERROR: failed to delete pool from set: set=${this.notExistingPoolSetKey}; key=${poolKey}`,
-        error,
-      );
-    }
-  };
+      try {
+        this.logger.info(
+          `${logPrefix} delete pool from not existing set=${this.notExistingPoolSetKey}; key=${poolKey}`,
+        );
+        // delete pool record from set
+        const result = await this.dexHelper.cache.zrem(
+          this.notExistingPoolSetKey,
+          [poolKey],
+        );
+        this.logger.info(
+          `${logPrefix} delete pool from not existing set=${this.notExistingPoolSetKey}; key=${poolKey}; result: ${result}`,
+        );
+      } catch (error) {
+        this.logger.error(
+          `${logPrefix} ERROR: failed to delete pool from set: set=${this.notExistingPoolSetKey}; key=${poolKey}`,
+          error,
+        );
+      }
+    };
+  }
 
   async getPool(
     srcAddress: Address,
     destAddress: Address,
     fee: bigint,
     blockNumber: number,
+    tickSpacing?: bigint,
   ): Promise<UniswapV3EventPool | null> {
     let pool = this.eventPools[
-      this.getPoolIdentifier(srcAddress, destAddress, fee)
+      this.getPoolIdentifier(srcAddress, destAddress, fee, tickSpacing)
     ] as UniswapV3EventPool | null | undefined;
 
     if (pool === null) return null;
@@ -272,7 +283,11 @@ export class UniswapV3
 
     const [token0, token1] = this._sortTokens(srcAddress, destAddress);
 
-    const key = `${token0}_${token1}_${fee}`.toLowerCase();
+    let key = `${token0}_${token1}_${fee}`.toLowerCase();
+
+    if (tickSpacing) {
+      key = `${key}_${tickSpacing}`;
+    }
 
     if (!pool) {
       const notExistingPoolScore = await this.dexHelper.cache.zscore(
@@ -283,43 +298,15 @@ export class UniswapV3
       const poolDoesNotExist = notExistingPoolScore !== null;
 
       if (poolDoesNotExist) {
-        this.eventPools[this.getPoolIdentifier(srcAddress, destAddress, fee)] =
-          null;
+        this.eventPools[
+          this.getPoolIdentifier(srcAddress, destAddress, fee, tickSpacing)
+        ] = null;
         return null;
       }
-
-      await this.dexHelper.cache.hset(
-        this.dexmapKey,
-        key,
-        JSON.stringify({
-          token0,
-          token1,
-          fee: fee.toString(),
-        }),
-      );
     }
 
     this.logger.trace(`starting to listen to new pool: ${key}`);
-    const poolImplementation =
-      this.config.eventPoolImplementation !== undefined
-        ? this.config.eventPoolImplementation
-        : UniswapV3EventPool;
-    pool =
-      pool ||
-      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,
-      );
+    pool = pool || this.getPoolInstance(token0, token1, fee, tickSpacing);
 
     try {
       await pool.initialize(blockNumber, {
@@ -374,16 +361,63 @@ export class UniswapV3
       );
     }
 
-    this.eventPools[this.getPoolIdentifier(srcAddress, destAddress, fee)] =
-      pool;
+    this.eventPools[
+      this.getPoolIdentifier(srcAddress, destAddress, fee, tickSpacing)
+    ] = pool;
     return pool;
   }
 
+  protected getPoolInstance(
+    token0: string,
+    token1: string,
+    fee: bigint,
+    tickSpacing?: bigint,
+  ) {
+    const poolImplementation =
+      this.config.eventPoolImplementation !== undefined
+        ? this.config.eventPoolImplementation
+        : UniswapV3EventPool;
+
+    return 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,
+      tickSpacing,
+    );
+  }
+
+  protected getFactoryInstance(): UniswapV3Factory {
+    const factoryImplementation =
+      this.config.factoryImplementation !== undefined
+        ? this.config.factoryImplementation
+        : UniswapV3Factory;
+
+    return new factoryImplementation(
+      this.dexHelper,
+      this.dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet().bind(this),
+    );
+  }
+
   async addMasterPool(poolKey: string, blockNumber: number): Promise<boolean> {
-    const _pairs = await this.dexHelper.cache.hget(this.dexmapKey, poolKey);
+    const _pairs = await this.dexHelper.cache.hget(
+      PoolsRegistryHashKey,
+      `${this.cacheStateKey}_${poolKey}`,
+    );
     if (!_pairs) {
       this.logger.warn(
-        `did not find poolConfig in for key ${this.dexmapKey} ${poolKey}`,
+        `did not find poolConfig in for key ${PoolsRegistryHashKey} ${this.cacheStateKey}_${poolKey}`,
       );
       return false;
     }
@@ -395,6 +429,9 @@ export class UniswapV3
       poolInfo.token1,
       BigInt(poolInfo.fee),
       blockNumber,
+      poolInfo.tickSpacing !== undefined
+        ? BigInt(poolInfo.tickSpacing)
+        : undefined,
     );
 
     if (!pool) {
@@ -421,17 +458,30 @@ export class UniswapV3
     if (_srcAddress === _destAddress) return [];
 
     const pools = (
-      await Promise.all(
-        this.supportedFees.map(async fee =>
-          this.getPool(_srcAddress, _destAddress, fee, blockNumber),
-        ),
-      )
+      await this.getPoolsForIdentifiers(_srcAddress, _destAddress, blockNumber)
     ).filter(pool => pool);
 
     if (pools.length === 0) return [];
 
     return pools.map(pool =>
-      this.getPoolIdentifier(_srcAddress, _destAddress, pool!.feeCode),
+      this.getPoolIdentifier(
+        _srcAddress,
+        _destAddress,
+        pool!.feeCode,
+        pool!.tickSpacing,
+      ),
+    );
+  }
+
+  protected async getPoolsForIdentifiers(
+    srcAddress: string,
+    destAddress: string,
+    blockNumber: number,
+  ): Promise<(UniswapV3EventPool | null)[]> {
+    return Promise.all(
+      this.supportedFees.map(async fee =>
+        this.getPool(srcAddress, destAddress, fee, blockNumber),
+      ),
     );
   }
 
@@ -568,6 +618,7 @@ export class UniswapV3
           pool.token0,
           pool.token1,
           pool.feeCode,
+          pool.tickSpacing,
         ),
         exchange: this.dexKey,
         gasCost: prices.map(p => (p === 0n ? 0 : UNISWAPV3_QUOTE_GASLIMIT)),
@@ -578,6 +629,29 @@ export class UniswapV3
     return result;
   }
 
+  protected async getSelectedPools(
+    srcAddress: string,
+    destAddress: string,
+    blockNumber: number,
+  ): Promise<(UniswapV3EventPool | null)[]> {
+    return Promise.all(
+      this.supportedFees.map(async fee => {
+        const locallyFoundPool =
+          this.eventPools[this.getPoolIdentifier(srcAddress, destAddress, fee)];
+
+        if (locallyFoundPool) return locallyFoundPool;
+
+        const newlyFetchedPool = await this.getPool(
+          srcAddress,
+          destAddress,
+          fee,
+          blockNumber,
+        );
+        return newlyFetchedPool;
+      }),
+    );
+  }
+
   async getPricesVolume(
     srcToken: Token,
     destToken: Token,
@@ -601,23 +675,7 @@ export class UniswapV3
 
       if (!limitPools) {
         selectedPools = (
-          await Promise.all(
-            this.supportedFees.map(async fee => {
-              const locallyFoundPool =
-                this.eventPools[
-                  this.getPoolIdentifier(_srcAddress, _destAddress, fee)
-                ];
-              if (locallyFoundPool) return locallyFoundPool;
-
-              const newlyFetchedPool = await this.getPool(
-                _srcAddress,
-                _destAddress,
-                fee,
-                blockNumber,
-              );
-              return newlyFetchedPool;
-            }),
-          )
+          await this.getSelectedPools(_srcAddress, _destAddress, blockNumber)
         ).filter(isTruthy);
       } else {
         const pairIdentifierWithoutFee = this.getPoolIdentifier(
@@ -637,12 +695,14 @@ export class UniswapV3
               let locallyFoundPool = this.eventPools[identifier];
               if (locallyFoundPool) return locallyFoundPool;
 
-              const [, srcAddress, destAddress, fee] = identifier.split('_');
+              const [, srcAddress, destAddress, fee, tickSpacing] =
+                identifier.split('_');
               const newlyFetchedPool = await this.getPool(
                 srcAddress,
                 destAddress,
                 BigInt(fee),
                 blockNumber,
+                tickSpacing !== undefined ? BigInt(tickSpacing) : undefined,
               );
               return newlyFetchedPool;
             }),
@@ -749,20 +809,12 @@ export class UniswapV3
           return {
             unit: unitResult.outputs[0],
             prices,
-            data: {
-              path: [
-                {
-                  tokenIn: _srcAddress,
-                  tokenOut: _destAddress,
-                  fee: pool.feeCode.toString(),
-                  currentFee: state.fee.toString(),
-                },
-              ],
-            },
+            data: this.prepareData(_srcAddress, _destAddress, pool, state),
             poolIdentifier: this.getPoolIdentifier(
               pool.token0,
               pool.token1,
               pool.feeCode,
+              pool.tickSpacing,
             ),
             exchange: this.dexKey,
             gasCost: gasCost,
@@ -796,6 +848,24 @@ export class UniswapV3
     }
   }
 
+  protected prepareData(
+    srcAddress: string,
+    destAddress: string,
+    pool: UniswapV3EventPool,
+    state: PoolState,
+  ): UniswapV3Data {
+    return {
+      path: [
+        {
+          tokenIn: srcAddress,
+          tokenOut: destAddress,
+          fee: pool.feeCode.toString(),
+          currentFee: state.fee.toString(),
+        },
+      ],
+    };
+  }
+
   getCalldataGasCost(poolPrices: PoolPrices<UniswapV3Data>): number | number[] {
     const gasCost =
       CALLDATA_GAS_COST.DEX_OVERHEAD +
@@ -969,8 +1039,8 @@ export class UniswapV3
       srcToken,
       destToken,
       fromAmount,
-      quotedAmount,
       toAmount,
+      quotedAmount,
       metadata,
       // uuidToBytes16(uuid),
       beneficiary,
@@ -1072,6 +1142,14 @@ export class UniswapV3
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.config.router,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.routerIface,
+              swapFunction,
+              'amountOut',
+            )
+          : undefined,
     };
   }
 
@@ -1123,6 +1201,8 @@ export class UniswapV3
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
+    if (!this.config.subgraphURL) return [];
+
     const _tokenAddress = tokenAddress.toLowerCase();
 
     const res = await this._querySubgraph(
@@ -1212,11 +1292,11 @@ export class UniswapV3
     return pools.filter(pool => pool) as UniswapV3EventPool[];
   }
 
-  private _getLoweredAddresses(srcToken: Token, destToken: Token) {
+  protected _getLoweredAddresses(srcToken: Token, destToken: Token) {
     return [srcToken.address.toLowerCase(), destToken.address.toLowerCase()];
   }
 
-  private _sortTokens(srcAddress: Address, destAddress: Address) {
+  protected _sortTokens(srcAddress: Address, destAddress: Address) {
     return [srcAddress, destAddress].sort((a, b) => (a < b ? -1 : 1));
   }
 
@@ -1236,13 +1316,14 @@ export class UniswapV3
       subgraphURL: this.config.subgraphURL,
       stateMultiCallAbi: this.config.stateMultiCallAbi,
       eventPoolImplementation: this.config.eventPoolImplementation,
+      factoryImplementation: this.config.factoryImplementation,
       decodeStateMultiCallResultWithRelativeBitmaps:
         this.config.decodeStateMultiCallResultWithRelativeBitmaps,
     };
     return newConfig;
   }
 
-  private _getOutputs(
+  protected _getOutputs(
     state: DeepReadonly<PoolState>,
     amounts: bigint[],
     zeroForOne: boolean,
@@ -1299,6 +1380,8 @@ export class UniswapV3
     variables: Object,
     timeout = 30000,
   ) {
+    if (!this.config.subgraphURL) return [];
+
     try {
       const res = await this.dexHelper.httpRequest.post(
         this.config.subgraphURL,
@@ -1313,7 +1396,7 @@ export class UniswapV3
     }
   }
 
-  private _encodePath(
+  protected _encodePath(
     path: {
       tokenIn: Address;
       tokenOut: Address;

package/src/dex/uniswap-v3.ts

@@ -15,6 +15,7 @@ import {
 import UniswapV3RouterABI from '../abi/UniswapV3Router.json';
 import { NumberAsString } from '@paraswap/core';
 import { IDexHelper } from '../dex-helper';
+import { extractReturnAmountPosition } from '../executor/utils';
 
 const UNISWAP_V3_ROUTER_ADDRESSES: { [network: number]: Address } = {
   [Network.MAINNET]: '0xE592427A0AEce92De3Edee1F18E0157C05861564',
@@ -228,6 +229,14 @@ export class UniswapV3
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.routerAddress,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+              'amountOut',
+            )
+          : undefined,
     };
   }
 }