@paraswap/dex-lib 3.3.0 → 3.3.1-return-amount-pos.1

package/build/dex/aave-v3/tokens/polygon.json

@@ -0,0 +1,116 @@
+[
+  {
+    "aSymbol": "aPolAGEUR",
+    "aAddress": "0x8437d7c167dfb82ed4cb79cd44b7a32a1dd95c77",
+    "address": "0xe0b52e49357fd4daf2c15e02058dce6bc0057db4",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolDAI",
+    "aAddress": "0x82e64f49ed5ec1bc6e43dad4fc8af9bb3a2312ee",
+    "address": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolEURS",
+    "aAddress": "0x38d693ce1df5aadf7bc62595a37d667ad57922e5",
+    "address": "0xe111178a87a3bff0c8d18decba5798827539ae99",
+    "decimals": 2
+  },
+  {
+    "aSymbol": "aPolJEUR",
+    "aAddress": "0x6533afac2e7bccb20dca161449a13a32d391fb00",
+    "address": "0x4e3decbb3645551b8a19f0ea1678079fcb33fb4c",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolMIMATIC",
+    "aAddress": "0xeBe517846d0F36eCEd99C735cbF6131e1fEB775D",
+    "address": "0xa3Fa99A148fA48D14Ed51d610c367C61876997F1",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolUSDC",
+    "aAddress": "0x625e7708f30ca75bfd92586e17077590c60eb4cd",
+    "address": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
+    "decimals": 6
+  },
+  {
+    "aSymbol": "aPolUSDT",
+    "aAddress": "0x6ab707aca953edaefbc4fd23ba73294241490620",
+    "address": "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+    "decimals": 6
+  },
+  {
+    "aSymbol": "aPolAAVE",
+    "aAddress": "0xf329e36c7bf6e5e86ce2150875a84ce77f477375",
+    "address": "0xd6df932a45c0f255f85145f286ea0b292b21c90b",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolBAL",
+    "aAddress": "0x8ffdf2de812095b1d19cb146e4c004587c0a0692",
+    "address": "0x9a71012b13ca4d3d0cdc72a177df3ef03b0e76a3",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolCRV",
+    "aAddress": "0x513c7e3a9c69ca3e22550ef58ac1c0088e918fff",
+    "address": "0x172370d5cd63279efa6d502dab29171933a610af",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolDPI",
+    "aAddress": "0x724dc807b04555b71ed48a6896b6f41593b8c637",
+    "address": "0x85955046df4668e1dd369d2de9f3aeb98dd2a369",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolGHST",
+    "aAddress": "0x8eb270e296023e9d92081fdf967ddd7878724424",
+    "address": "0x385eeac5cb85a38a9a07a70c73e0a3271cfb54a7",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolLINK",
+    "aAddress": "0x191c10aa4af7c30e871e70c95db0e4eb77237530",
+    "address": "0x53e0bca35ec356bd5dddfebbd1fc0fd03fabad39",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolMATICX",
+    "aAddress": "0x80cA0d8C38d2e2BcbaB66aA1648Bd1C7160500FE",
+    "address": "0xfa68FB4628DFF1028CFEc22b4162FCcd0d45efb6",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolSTMATIC",
+    "aAddress": "0xEA1132120ddcDDA2F119e99Fa7A27a0d036F7Ac9",
+    "address": "0x3A58a54C066FdC0f2D55FC9C89F0415C92eBf3C4",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolSUSHI",
+    "aAddress": "0xc45a479877e1e9dfe9fcd4056c699575a1045daa",
+    "address": "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolWBTC",
+    "aAddress": "0x078f358208685046a11c85e8ad32895ded33a249",
+    "address": "0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6",
+    "decimals": 8
+  },
+  {
+    "aSymbol": "aPolWETH",
+    "aAddress": "0xe50fa9b3c56ffb159cb0fca61f5c9d750e8128c8",
+    "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
+    "decimals": 18
+  },
+  {
+    "aSymbol": "aPolWMATIC",
+    "aAddress": "0x6d80113e533a2c0fe82eabd35f1875dcea89ea97",
+    "address": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+    "decimals": 18
+  }
+]

package/build/dex/algebra/algebra-pool.d.ts

@@ -0,0 +1,114 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { Address, BlockHeader, Log, Logger } from '../../types';
+import {
+  InitializeStateOptions,
+  StatefulEventSubscriber,
+} from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolState } from './types';
+import { Contract } from 'web3-eth-contract';
+import { DecodedStateMultiCallResultWithRelativeBitmaps } from './types';
+export declare class AlgebraEventPool extends StatefulEventSubscriber<PoolState> {
+  readonly dexHelper: IDexHelper;
+  readonly stateMultiContract: Contract;
+  readonly erc20Interface: Interface;
+  protected readonly factoryAddress: Address;
+  readonly poolInitCodeHash: string;
+  readonly poolDeployer: string;
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+      blockHeader: BlockHeader,
+    ) => DeepReadonly<PoolState> | null;
+  };
+  logDecoder: (log: Log) => any;
+  addressesSubscribed: string[];
+  private _poolAddress?;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly poolIface: Interface;
+  initFailed: boolean;
+  initRetryAttemptCount: number;
+  constructor(
+    dexHelper: IDexHelper,
+    parentName: string,
+    stateMultiContract: Contract,
+    erc20Interface: Interface,
+    factoryAddress: Address,
+    token0: Address,
+    token1: Address,
+    logger: Logger,
+    mapKey: string | undefined,
+    poolInitCodeHash: string,
+    poolDeployer: string,
+  );
+  get poolAddress(): Address;
+  set poolAddress(address: Address);
+  initialize(
+    blockNumber: number,
+    options?: InitializeStateOptions<PoolState>,
+  ): Promise<void>;
+  protected processBlockLogs(
+    state: DeepReadonly<PoolState>,
+    logs: Readonly<Log>[],
+    blockHeader: Readonly<BlockHeader>,
+  ): Promise<DeepReadonly<PoolState> | null>;
+  protected processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<PoolState> | null;
+  getBitmapRangeToRequest(): bigint;
+  private _fetchPoolStateSingleStep;
+  private _fetchPoolStateMultiStep;
+  _fetchInitStateMultiStrategies(
+    blockNumber: number,
+  ): Promise<[bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmaps]>;
+  generateState(blockNumber: number): Promise<Readonly<PoolState>>;
+  handleSwapEvent(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleMintEvent(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleBurnEvent(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleNewFee(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleCollectEvent(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleFlashEvent(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  handleCommunityFee(
+    event: any,
+    pool: PoolState,
+    log: Log,
+    blockHeader: BlockHeader,
+  ): PoolState;
+  private _computePoolAddress;
+}

package/build/dex/algebra/algebra-pool.js

@@ -0,0 +1,448 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.AlgebraEventPool = void 0;
+const lodash_1 = __importDefault(require('lodash'));
+const abi_1 = require('@ethersproject/abi');
+const ts_essentials_1 = require('ts-essentials');
+const utils_1 = require('../../utils');
+const stateful_event_subscriber_1 = require('../../stateful-event-subscriber');
+const ethers_1 = require('ethers');
+const AlgebraPool_abi_json_1 = __importDefault(
+  require('../../abi/algebra/AlgebraPool.abi.json'),
+);
+const constants_1 = require('../uniswap-v3/constants');
+const decoders_1 = require('../../lib/decoders');
+const utils_2 = require('./utils');
+const AlgebraMath_1 = require('./lib/AlgebraMath');
+const TickBitMap_1 = require('../uniswap-v3/contract-math/TickBitMap');
+const utils_3 = require('../uniswap-v3/contract-math/utils');
+const Constants_1 = require('./lib/Constants');
+const constants_2 = require('../../constants');
+class AlgebraEventPool extends stateful_event_subscriber_1.StatefulEventSubscriber {
+  constructor(
+    dexHelper,
+    parentName,
+    stateMultiContract,
+    erc20Interface,
+    factoryAddress,
+    token0,
+    token1,
+    logger,
+    mapKey = '',
+    poolInitCodeHash,
+    poolDeployer,
+  ) {
+    super(parentName, `${token0}_${token1}`, dexHelper, logger, true, mapKey);
+    this.dexHelper = dexHelper;
+    this.stateMultiContract = stateMultiContract;
+    this.erc20Interface = erc20Interface;
+    this.factoryAddress = factoryAddress;
+    this.poolInitCodeHash = poolInitCodeHash;
+    this.poolDeployer = poolDeployer;
+    this.handlers = {};
+    this.poolIface = new abi_1.Interface(AlgebraPool_abi_json_1.default);
+    this.initFailed = false;
+    this.initRetryAttemptCount = 0;
+    this.token0 = token0.toLowerCase();
+    this.token1 = token1.toLowerCase();
+    this.logDecoder = log => this.poolIface.parseLog(log);
+    this.addressesSubscribed = new Array(1);
+    this.handlers['Fee'] = this.handleNewFee.bind(this);
+    this.handlers['Swap'] = this.handleSwapEvent.bind(this);
+    this.handlers['Mint'] = this.handleMintEvent.bind(this);
+    this.handlers['Burn'] = this.handleBurnEvent.bind(this);
+    this.handlers['Flash'] = this.handleFlashEvent.bind(this);
+    this.handlers['Collect'] = this.handleCollectEvent.bind(this);
+    this.handlers['CommunityFee'] = this.handleCommunityFee.bind(this);
+  }
+  get poolAddress() {
+    if (this._poolAddress === undefined) {
+      this._poolAddress = this._computePoolAddress(this.token0, this.token1);
+    }
+    return this._poolAddress;
+  }
+  set poolAddress(address) {
+    this._poolAddress = address.toLowerCase();
+  }
+  async initialize(blockNumber, options) {
+    await super.initialize(blockNumber, options);
+  }
+  async processBlockLogs(state, logs, blockHeader) {
+    const newState = await super.processBlockLogs(state, logs, blockHeader);
+    if (newState && !newState.isValid) {
+      return await this.generateState(blockHeader.number);
+    }
+    return newState;
+  }
+  processLog(state, log, blockHeader) {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        // Because we have observations in array which is mutable by nature, there is a
+        // ts compile error: https://stackoverflow.com/questions/53412934/disable-allowing-assigning-readonly-types-to-non-readonly-types
+        // And there is no good workaround, so turn off the type checker for this line
+        const _state = lodash_1.default.cloneDeep(state);
+        try {
+          const newState = this.handlers[event.name](
+            event,
+            _state,
+            log,
+            blockHeader,
+          );
+          return newState;
+        } catch (e) {
+          if (
+            e instanceof Error &&
+            e.message.endsWith(constants_1.OUT_OF_RANGE_ERROR_POSTFIX)
+          ) {
+            this.logger.warn(
+              `${this.parentName}: Pool ${this.poolAddress} on ${
+                this.dexHelper.config.data.network
+              } is out of TickBitmap requested range. Re-query the state. ${JSON.stringify(
+                event,
+              )}`,
+              e,
+            );
+          } else {
+            this.logger.error(
+              `${this.parentName}: Pool ${this.poolAddress}, ` +
+                `network=${this.dexHelper.config.data.network}: Unexpected ` +
+                `error while handling event on blockNumber=${blockHeader.number}, ` +
+                `blockHash=${blockHeader.hash} and parentHash=${
+                  blockHeader.parentHash
+                } for QuickSwapV3, ${JSON.stringify(event)}`,
+              e,
+            );
+          }
+          _state.isValid = false;
+          return _state;
+        }
+      }
+    } catch (e) {
+      (0, utils_1.catchParseLogError)(e, this.logger);
+    }
+    return null; // ignore unrecognized event
+  }
+  getBitmapRangeToRequest() {
+    return constants_1.TICK_BITMAP_TO_USE + constants_1.TICK_BITMAP_BUFFER;
+  }
+  async _fetchPoolStateSingleStep(blockNumber) {
+    const callData = [
+      {
+        target: this.token0,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: decoders_1.uint256ToBigInt,
+      },
+      {
+        target: this.token1,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: decoders_1.uint256ToBigInt,
+      },
+      {
+        target: this.stateMultiContract.options.address,
+        callData: this.stateMultiContract.methods
+          .getFullStateWithRelativeBitmaps(
+            this.factoryAddress,
+            this.token0,
+            this.token1,
+            this.getBitmapRangeToRequest(),
+            this.getBitmapRangeToRequest(),
+          )
+          .encodeABI(),
+        decodeFunction: utils_2.decodeStateMultiCallResultWithRelativeBitmaps,
+      },
+    ];
+    const [resBalance0, resBalance1, resState] =
+      await this.dexHelper.multiWrapper.tryAggregate(
+        false,
+        callData,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+    (0, ts_essentials_1.assert)(resState.success, 'Pool does not exist');
+    const [balance0, balance1, _state] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      resState.returnData,
+    ];
+    return [balance0, balance1, _state];
+  }
+  async _fetchPoolStateMultiStep(blockNumber) {
+    const balancesAndGlobalStateCalldata = [
+      {
+        target: this.token0,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: decoders_1.uint256ToBigInt,
+      },
+      {
+        target: this.token1,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: decoders_1.uint256ToBigInt,
+      },
+      {
+        target: this.stateMultiContract.options.address,
+        callData: this.stateMultiContract.methods
+          .getFullStateWithoutTicks(
+            this.factoryAddress,
+            this.token0,
+            this.token1,
+            0,
+            0,
+          )
+          .encodeABI(),
+        decodeFunction: utils_2.decodeStateMultiCallResultWithRelativeBitmaps,
+      },
+    ];
+    const [resBalance0, resBalance1, stateWithoutTicksAndTickBitmap] =
+      await this.dexHelper.multiWrapper.tryAggregate(
+        false,
+        balancesAndGlobalStateCalldata,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+    (0, ts_essentials_1.assert)(
+      stateWithoutTicksAndTickBitmap.success,
+      'Pool does not exist',
+    );
+    const [balance0, balance1, _stateWithoutTicksAndTickBitmap] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      stateWithoutTicksAndTickBitmap.returnData,
+    ];
+    const {
+      globalState: { tick },
+    } = _stateWithoutTicksAndTickBitmap;
+    const currentBitmapIndex = (0, utils_1.int16)(
+      (BigInt(tick) / Constants_1.Constants.TICK_SPACING) >> 8n,
+    );
+    const buffer = this.getBitmapRangeToRequest();
+    const startBitMapIndex = currentBitmapIndex - buffer;
+    const endBitMapIndex = currentBitmapIndex + buffer;
+    const allBitMapIndices = Array.from(
+      { length: 2 * Number(buffer) + 1 },
+      () => startBitMapIndex + endBitMapIndex,
+    );
+    const ticksAndBitMaps = await Promise.all(
+      allBitMapIndices.map(relativeTick => {
+        return this.stateMultiContract.methods
+          .getAdditionalBitmapWithTicks(
+            this.factoryAddress,
+            this.token0,
+            this.token1,
+            relativeTick,
+            relativeTick,
+          )
+          .call();
+      }),
+    );
+    const _state = {
+      ..._stateWithoutTicksAndTickBitmap,
+      tickBitmap: ticksAndBitMaps.flatMap(v => v[0]),
+      ticks: ticksAndBitMaps.flatMap(v => v[1]),
+    };
+    return [balance0, balance1, _state];
+  }
+  async _fetchInitStateMultiStrategies(blockNumber) {
+    try {
+      return await this._fetchPoolStateSingleStep(blockNumber);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes('Pool does not exist'))
+        throw e;
+      if (this.dexHelper.config.data.network != constants_2.Network.ZKEVM)
+        throw e;
+      return this._fetchPoolStateMultiStep(blockNumber);
+    }
+  }
+  async generateState(blockNumber) {
+    const [balance0, balance1, _state] =
+      await this._fetchInitStateMultiStrategies(blockNumber);
+    const tickBitmap = {};
+    const ticks = {};
+    (0, utils_3._reduceTickBitmap)(tickBitmap, _state.tickBitmap);
+    (0, utils_3._reduceTicks)(ticks, _state.ticks);
+    const globalState = {
+      communityFeeToken0: (0, utils_1.bigIntify)(
+        _state.globalState.communityFeeToken0,
+      ),
+      communityFeeToken1: (0, utils_1.bigIntify)(
+        _state.globalState.communityFeeToken1,
+      ),
+      fee: (0, utils_1.bigIntify)(_state.globalState.fee),
+      price: (0, utils_1.bigIntify)(_state.globalState.price),
+      tick: (0, utils_1.bigIntify)(_state.globalState.tick),
+    };
+    const currentTick = globalState.tick;
+    const startTickBitmap = TickBitMap_1.TickBitMap.position(
+      BigInt(currentTick) / Constants_1.Constants.TICK_SPACING,
+    )[0];
+    return {
+      pool: _state.pool,
+      blockTimestamp: (0, utils_1.bigIntify)(_state.blockTimestamp),
+      globalState,
+      liquidity: (0, utils_1.bigIntify)(_state.liquidity),
+      tickSpacing: Constants_1.Constants.TICK_SPACING,
+      maxLiquidityPerTick: Constants_1.Constants.MAX_LIQUIDITY_PER_TICK,
+      tickBitmap,
+      ticks,
+      startTickBitmap,
+      isValid: true,
+      balance0,
+      balance1,
+    };
+  }
+  handleSwapEvent(event, pool, log, blockHeader) {
+    const newSqrtPriceX96 = (0, utils_1.bigIntify)(event.args.price);
+    const amount0 = (0, utils_1.bigIntify)(event.args.amount0);
+    const amount1 = (0, utils_1.bigIntify)(event.args.amount1);
+    const newTick = (0, utils_1.bigIntify)(event.args.tick);
+    const newLiquidity = (0, utils_1.bigIntify)(event.args.liquidity);
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    if (amount0 <= 0n && amount1 <= 0n) {
+      this.logger.error(
+        `${this.parentName}: amount0 <= 0n && amount1 <= 0n for ` +
+          `${this.poolAddress} and ${blockHeader.number}. Check why it happened`,
+      );
+      pool.isValid = false;
+      return pool;
+    } else {
+      const zeroForOne = amount0 > 0n;
+      const [, , , , , communityFee] =
+        AlgebraMath_1.AlgebraMath._calculateSwapAndLock(
+          pool,
+          zeroForOne,
+          newSqrtPriceX96,
+          newTick,
+          newLiquidity,
+        );
+      if (zeroForOne) {
+        if (amount1 < 0n) {
+          pool.balance1 -= BigInt.asUintN(256, -amount1);
+        } else {
+          this.logger.error(
+            `In swapEvent for pool ${pool.pool} received incorrect values ${zeroForOne} and ${amount1}`,
+          );
+          pool.isValid = false;
+        }
+        // This is not correct fully, because pool may get more tokens then it needs, but
+        // it is not accounted in internal state, it should be good enough
+        pool.balance0 += BigInt.asUintN(256, amount0);
+      } else {
+        if (amount0 < 0n) {
+          pool.balance0 -= BigInt.asUintN(256, -amount0);
+        } else {
+          this.logger.error(
+            `In swapEvent for pool ${pool.pool} received incorrect values ${zeroForOne} and ${amount0}`,
+          );
+          pool.isValid = false;
+        }
+        pool.balance1 += BigInt.asUintN(256, amount1);
+      }
+      if (communityFee > 0n) {
+        // _payCommunityFee
+        if (zeroForOne) {
+          pool.balance0 -= communityFee;
+        } else {
+          pool.balance1 -= communityFee;
+        }
+      }
+      return pool;
+    }
+  }
+  handleMintEvent(event, pool, log, blockHeader) {
+    const bottomTick = (0, utils_1.bigIntify)(event.args.bottomTick);
+    const topTick = (0, utils_1.bigIntify)(event.args.topTick);
+    const liquidityActual = (0, utils_1.bigIntify)(event.args.liquidityAmount);
+    const amount0 = (0, utils_1.bigIntify)(event.args.amount0);
+    const amount1 = (0, utils_1.bigIntify)(event.args.amount1);
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    AlgebraMath_1.AlgebraMath._updatePositionTicksAndFees(
+      pool,
+      bottomTick,
+      topTick,
+      liquidityActual,
+    );
+    pool.balance0 += amount0;
+    pool.balance1 += amount1;
+    return pool;
+  }
+  handleBurnEvent(event, pool, log, blockHeader) {
+    const bottomTick = (0, utils_1.bigIntify)(event.args.bottomTick);
+    const topTick = (0, utils_1.bigIntify)(event.args.topTick);
+    const amount = (0, utils_1.bigIntify)(event.args.liquidityAmount);
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    AlgebraMath_1.AlgebraMath._updatePositionTicksAndFees(
+      pool,
+      bottomTick,
+      topTick,
+      -BigInt.asIntN(128, BigInt.asIntN(256, amount)),
+    );
+    // no balance change
+    return pool;
+  }
+  handleNewFee(event, pool, log, blockHeader) {
+    const fee = (0, utils_1.bigIntify)(event.args.fee);
+    pool.globalState.fee = fee;
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    return pool;
+  }
+  handleCollectEvent(event, pool, log, blockHeader) {
+    const amount0 = (0, utils_1.bigIntify)(event.args.amount0);
+    const amount1 = (0, utils_1.bigIntify)(event.args.amount1);
+    pool.balance0 -= amount0;
+    pool.balance1 -= amount1;
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    return pool;
+  }
+  handleFlashEvent(event, pool, log, blockHeader) {
+    const paid0 = (0, utils_1.bigIntify)(event.args.paid0);
+    const paid1 = (0, utils_1.bigIntify)(event.args.paid1);
+    pool.balance0 += paid0;
+    pool.balance1 += paid1;
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    return pool;
+  }
+  handleCommunityFee(event, pool, log, blockHeader) {
+    const communityFeeToken0 = (0, utils_1.bigIntify)(
+      event.ags.communityFee0New,
+    );
+    const communityFeeToken1 = (0, utils_1.bigIntify)(
+      event.ags.communityFee1New,
+    );
+    pool.globalState.communityFeeToken0 = communityFeeToken0;
+    pool.globalState.communityFeeToken1 = communityFeeToken1;
+    pool.blockTimestamp = (0, utils_1.bigIntify)(blockHeader.timestamp);
+    return pool;
+  }
+  _computePoolAddress(token0, token1) {
+    // https://github.com/Uniswap/v3-periphery/blob/main/contracts/libraries/PoolAddress.sol
+    if (token0 > token1) [token0, token1] = [token1, token0];
+    const encodedKey = ethers_1.ethers.utils.keccak256(
+      ethers_1.ethers.utils.defaultAbiCoder.encode(
+        ['address', 'address'],
+        [token0, token1],
+      ),
+    );
+    return ethers_1.ethers.utils.getCreate2Address(
+      this.poolDeployer,
+      encodedKey,
+      this.poolInitCodeHash,
+    );
+  }
+}
+exports.AlgebraEventPool = AlgebraEventPool;
+//# sourceMappingURL=algebra-pool.js.map