@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

package/src/dex/algebra/algebra-pool-v1_1.ts

@@ -9,31 +9,47 @@ import {
 } from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
+  DecodedGlobalStateV1_1,
   PoolStateV1_1,
   TickBitMapMappingsWithBigNumber,
   TickInfoMappingsWithBigNumber,
+  TickInfoWithBigNumber,
 } from './types';
-import { ethers } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import { Contract } from 'web3-eth-contract';
 import AlgebraABI from '../../abi/algebra/AlgebraPool-v1_1.abi.json';
+import FactoryABI from '../../abi/algebra/AlgebraFactory-v1_1.abi.json';
 import { DecodedStateMultiCallResultWithRelativeBitmapsV1_1 } from './types';
 import {
   OUT_OF_RANGE_ERROR_POSTFIX,
   TICK_BITMAP_BUFFER,
   TICK_BITMAP_TO_USE,
 } from '../uniswap-v3/constants';
-import { uint256ToBigInt } from '../../lib/decoders';
+import {
+  addressDecode,
+  uint256ToBigInt,
+  uint128ToBigNumber,
+  int24ToNumber,
+} from '../../lib/decoders';
 import { MultiCallParams } from '../../lib/multi-wrapper';
-import { decodeStateMultiCallResultWithRelativeBitmapsV1_1 } from './utils';
+import {
+  decodeGlobalStateV1_1,
+  decodeStateMultiCallResultWithRelativeBitmapsV1_1,
+  decodeTicksV1_1,
+} from './utils';
 import { AlgebraMath } from './lib/AlgebraMath';
 import {
   _reduceTickBitmap,
   _reduceTicks,
 } from '../uniswap-v3/contract-math/utils';
 import { Constants } from './lib/Constants';
-import { Network } from '../../constants';
+import { Network, NULL_ADDRESS } from '../../constants';
 import { TickTable } from './lib/TickTable';
 
+const BN_ZERO = BigNumber.from(0);
+const MAX_BATCH_SIZE = 100;
+const MAX_NUMBER_OF_BATCH_REQUEST_HALVING = 3;
+
 export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1> {
   handlers: {
     [event: string]: (
@@ -53,6 +69,13 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
   readonly token1: Address;
 
   public readonly poolIface = new Interface(AlgebraABI);
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  private readonly cachedStateMultiCalls: MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[];
+
+  private optimalTickRequestBatchSize?: number;
 
   public initFailed = false;
   public initRetryAttemptCount = 0;
@@ -69,6 +92,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     mapKey: string = '',
     readonly poolInitCodeHash: string,
     readonly poolDeployer: string,
+    private readonly forceManualStateGeneration: boolean = false,
   ) {
     super(parentName, `${token0}_${token1}`, dexHelper, logger, true, mapKey);
     this.token0 = token0.toLowerCase();
@@ -84,6 +108,8 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     this.handlers['Flash'] = this.handleFlashEvent.bind(this);
     this.handlers['Collect'] = this.handleCollectEvent.bind(this);
     this.handlers['CommunityFee'] = this.handleCommunityFee.bind(this);
+
+    this.cachedStateMultiCalls = this._getStateMulticall();
   }
 
   get poolAddress() {
@@ -174,7 +200,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     return TICK_BITMAP_TO_USE + TICK_BITMAP_BUFFER;
   }
 
-  private async _fetchPoolStateSingleStep(
+  async fetchPoolStateSingleStep(
     blockNumber: number,
   ): Promise<
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
@@ -336,7 +362,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
   > {
     try {
-      return await this._fetchPoolStateSingleStep(blockNumber);
+      return await this.fetchPoolStateSingleStep(blockNumber);
     } catch (e) {
       if (e instanceof Error && e.message.includes('Pool does not exist'))
         throw e;
@@ -347,9 +373,234 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     }
   }
 
+  private _getStateMulticall(): MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[] {
+    return [
+      {
+        target: this.factoryAddress,
+        callData: this.factoryIface.encodeFunctionData('poolByPair', [
+          this.token0,
+          this.token1,
+        ]),
+        decodeFunction: addressDecode,
+      },
+      {
+        target: this.token0,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.token1,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('liquidity', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('tickSpacing', []),
+        decodeFunction: int24ToNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('maxLiquidityPerTick', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('globalState', []),
+        decodeFunction: decodeGlobalStateV1_1,
+      },
+    ];
+  }
+
+  async fetchStateManually(
+    blockNumber: number,
+  ): Promise<
+    [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
+  > {
+    // Unfortunately I can not unite this call with the next one. For some reason even if pool does not exist
+    // call succeeds and makes decoding function to throw. Otherwise, I should rewrite decoders in different which
+    // require some time
+    const [poolAddress] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(0, 1), blockNumber, MAX_BATCH_SIZE)) as [
+      string,
+    ];
+
+    if (poolAddress === NULL_ADDRESS) {
+      throw new Error('Pool does not exist');
+    }
+
+    const [
+      balance0,
+      balance1,
+      liquidity,
+      tickSpacing,
+      maxLiquidityPerTick,
+      globalState,
+    ] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(1), blockNumber, MAX_BATCH_SIZE)) as [
+      bigint,
+      bigint,
+      BigNumber,
+      number,
+      BigNumber,
+      DecodedGlobalStateV1_1,
+    ];
+
+    assert(
+      poolAddress.toLowerCase() === this.poolAddress.toLowerCase(),
+      `Pool address mismatch: ${poolAddress.toLowerCase()} != ${this.poolAddress.toLowerCase()}`,
+    );
+
+    const currentBitMapIndex = TickTable.position(
+      BigInt(BigInt(globalState.tick) / BigInt(tickSpacing)),
+    )[0];
+
+    const leftBitMapIndex = currentBitMapIndex - this.getBitmapRangeToRequest();
+    const rightBitMapIndex =
+      currentBitMapIndex + this.getBitmapRangeToRequest();
+
+    const allTickBitMaps = await this.dexHelper.multiWrapper.aggregate(
+      _.range(Number(leftBitMapIndex), Number(rightBitMapIndex + 1n)).map(
+        index => {
+          return {
+            target: poolAddress,
+            callData: this.poolIface.encodeFunctionData('tickTable', [
+              int16(BigInt(index)),
+            ]),
+            decodeFunction: uint256ToBigInt,
+          };
+        },
+      ),
+      blockNumber,
+      MAX_BATCH_SIZE,
+    );
+
+    const tickBitmap: TickBitMapMappingsWithBigNumber[] = [];
+
+    let globalIndex = 0;
+    for (let i = leftBitMapIndex; i <= rightBitMapIndex; i++) {
+      const index = Number(int16(i));
+      const bitmap = allTickBitMaps[globalIndex];
+      globalIndex++;
+      if (bitmap == 0n) continue;
+      tickBitmap.push({ index: Number(index), value: BigNumber.from(bitmap) });
+    }
+
+    const tickIndexes: bigint[] = [];
+
+    const tickRequests = tickBitmap
+      .map(tb => {
+        const allBits: MultiCallParams<TickInfoWithBigNumber>[] = [];
+        if (tb.value === BN_ZERO) return allBits;
+
+        _.range(0, 256).forEach(j => {
+          if ((tb.value.toBigInt() & (1n << BigInt(j))) > 0n) {
+            const populatedTick =
+              (BigInt.asIntN(16, BigInt(tb.index) << 8n) + BigInt(j)) *
+              BigInt(tickSpacing);
+
+            tickIndexes.push(populatedTick);
+            allBits.push({
+              target: poolAddress,
+              callData: this.poolIface.encodeFunctionData('ticks', [
+                populatedTick,
+              ]),
+              decodeFunction: decodeTicksV1_1,
+            });
+          }
+        });
+        return allBits;
+      })
+      .flat();
+
+    let ticksValues: TickInfoWithBigNumber[] = [];
+    if (this.optimalTickRequestBatchSize) {
+      ticksValues = await this.dexHelper.multiWrapper.aggregate(
+        tickRequests,
+        blockNumber,
+        this.optimalTickRequestBatchSize,
+      );
+      // If we don't know what is optimal number of requests for this pool, we want to try it experimentally and save it
+      // Maybe later to consider distant caching
+    } else {
+      for (const i of _.range(0, MAX_NUMBER_OF_BATCH_REQUEST_HALVING)) {
+        const currentBatchSize = MAX_BATCH_SIZE / (+i + 1);
+        try {
+          // Some of the pools fails with 100 batch size, for them we want to try additionally with reduced batch size
+          ticksValues = await this.dexHelper.multiWrapper.aggregate(
+            tickRequests,
+            blockNumber,
+            currentBatchSize,
+          );
+          this.optimalTickRequestBatchSize = currentBatchSize;
+          break;
+        } catch (e) {
+          if (+i + 1 === MAX_NUMBER_OF_BATCH_REQUEST_HALVING) {
+            this.logger.warn(
+              `Failed to fetch ticks for pool ${poolAddress} (${this.token0}_${this.token1}) with batch size ${currentBatchSize}`,
+              e,
+            );
+            throw e;
+          }
+        }
+      }
+    }
+
+    assert(
+      tickIndexes.length === ticksValues.length,
+      `Tick indexes mismatch: ${tickIndexes.length} != ${ticksValues.length}`,
+    );
+
+    const ticks: TickInfoMappingsWithBigNumber[] = new Array(
+      tickIndexes.length,
+    );
+
+    tickIndexes.forEach((tickIndex, index) => {
+      ticks[index] = {
+        index: Number(tickIndex),
+        value: ticksValues[index],
+      };
+    });
+
+    return [
+      balance0,
+      balance1,
+      {
+        pool: poolAddress,
+        blockTimestamp: BigNumber.from(Date.now()),
+        globalState,
+        liquidity,
+        tickSpacing,
+        maxLiquidityPerTick,
+        tickBitmap,
+        ticks,
+      },
+    ];
+  }
+
   async generateState(blockNumber: number): Promise<Readonly<PoolStateV1_1>> {
-    const [balance0, balance1, _state] =
-      await this._fetchInitStateMultiStrategies(blockNumber);
+    let balance0 = 0n;
+    let balance1 = 0n;
+    let _state: DecodedStateMultiCallResultWithRelativeBitmapsV1_1;
+    if (this.forceManualStateGeneration) {
+      [balance0, balance1, _state] = await this.fetchStateManually(blockNumber);
+    } else {
+      [balance0, balance1, _state] = await this._fetchInitStateMultiStrategies(
+        blockNumber,
+      );
+    }
 
     const tickBitmap = {};
     const ticks = {};

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> = {};
 
@@ -88,7 +90,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     protected adapters = Adapters[network] || {},
     readonly routerIface = new Interface(UniswapV3RouterABI), // same abi as uniswapV3
     readonly quoterIface = new Interface(AlgebraQuoterABI),
-    protected config = AlgebraConfig[dexKey][network],
+    readonly config = AlgebraConfig[dexKey][network],
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(dexKey + '-' + network);
@@ -104,12 +106,24 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     this.dexHelper.web3Provider.eth.handleRevert = false;
 
     this.config = this._toLowerForAllConfigAddresses();
+    // External configuration has priority over internal
+    this.config.forceRPC = dexHelper.config.data.forceRpcFallbackDexs.includes(
+      dexKey.toLowerCase(),
+    );
 
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
 
     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 {
@@ -122,6 +136,9 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
   }
 
   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 =
@@ -140,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}`;
+
+    // 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,
@@ -156,14 +204,15 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         if (this.network !== Network.ZKEVM) return pool;
 
         if (
-          pool.getState(blockNumber) === null &&
-          blockNumber - pool.getStateBlockNumber() >
-            MAX_STALE_STATE_BLOCK_AGE[this.network]
+          pool.getStaleState() === null ||
+          (pool.getState(blockNumber) === null &&
+            blockNumber - pool.getStateBlockNumber() >
+              MAX_STALE_STATE_BLOCK_AGE[this.network])
         ) {
           /* reload state, on zkEVM this would most likely timeout during request life
            * but would allow to rely on staleState for couple of min for next requests
            */
-          await pool.initialize(blockNumber);
+          await pool.initialize(blockNumber, { forceRegenerate: true });
         }
 
         return pool;
@@ -222,6 +271,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         this.cacheStateKey,
         this.config.initHash,
         this.config.deployer,
+        this.config.forceManualStateGenerate,
       );
 
     try {
@@ -251,10 +301,10 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           e,
         );
       } else {
-        // on unkown error mark as failed and increase retryCount for retry init strategy
+        // 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}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} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
           e,
         );
         pool.initFailed = true;
@@ -446,6 +496,18 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
 
       if (!pool) return null;
 
+      if (this.config.forceRPC) {
+        const rpcPrice = await this.getPricingFromRpc(
+          _srcToken,
+          _destToken,
+          amounts,
+          side,
+          pool,
+        );
+
+        return rpcPrice;
+      }
+
       let state = pool.getState(blockNumber);
 
       if (state === null) {
@@ -773,6 +835,8 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       initHash: this.config.initHash,
       subgraphURL: this.config.subgraphURL,
       version: this.config.version,
+      forceRPC: this.config.forceRPC,
+      forceManualStateGenerate: this.config.forceManualStateGenerate,
     };
     return newConfig;
   }
@@ -797,20 +861,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           return null;
         }
 
-        // TODO buy
-        let lastNonZeroOutput = 0n;
-        let lastNonZeroTickCountsOutputs = 0;
-
         for (let i = 0; i < outputsResult.outputs.length; i++) {
-          // local pricing algo may output 0s at the tail for some out of range amounts, prefer to propagating last amount to appease top algo
-          if (outputsResult.outputs[i] > 0n) {
-            lastNonZeroOutput = outputsResult.outputs[i];
-            lastNonZeroTickCountsOutputs = outputsResult.tickCounts[i];
-          } else {
-            outputsResult.outputs[i] = lastNonZeroOutput;
-            outputsResult.tickCounts[i] = lastNonZeroTickCountsOutputs;
-          }
-
           if (outputsResult.outputs[i] > destTokenBalance) {
             outputsResult.outputs[i] = 0n;
             outputsResult.tickCounts[i] = 0;

package/src/dex/algebra/config.ts

@@ -33,6 +33,7 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x61530d6E1c7A47BBB3e48e8b8EdF7569DcFeE121',
       deployer: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
       version: 'v1.1',
+      forceManualStateGenerate: true,
     },
   },
   ZyberSwapV3: {