@paraswap/dex-lib 2.13.1 → 2.14.0

package/src/lib/log-messages-suppressor.ts

@@ -1,173 +0,0 @@
-import { assert } from 'ts-essentials';
-import _ from 'lodash';
-import { Logger, LogLevels } from '../types';
-import { Utils } from '../utils';
-
-export const DEFAULT_LOG_PUBLISH_PERIOD_MS = 60_000;
-
-// After this period previous logs, even if unpublished, would be discarded
-// Because most likely they are outdated
-export const DEFAULT_LOG_DISCARD_PERIOD_MS = 15 * 60 * 1000;
-
-// We may have hundreds of pools failing at the same time,
-// and we don't want to show them all
-export const DEFAULT_LOG_MAX_IDENTITIES_TO_SHOW = 10;
-
-export type StandardStringEnum = Readonly<Record<string, string>>;
-
-export type MessageInfo<T extends StandardStringEnum> = {
-  key: keyof T;
-  message: T[keyof T];
-  logLevel: LogLevels;
-};
-
-export type MessageData = {
-  counter: number;
-  lastLoggedAtMs: number;
-  identificationInfos: string[];
-};
-
-export type AggregatedLogForEntity<T extends StandardStringEnum> = {
-  [key in keyof T]?: MessageData;
-};
-
-/*
- * This is helper module to reduce frequency of logging of spamming messages
- *
- * 1. You can only have predefined set of log messages to log
- * First time log message is received, it is published with all arguments.
- * Limitation - message can not include variables, but you can pass them as args
- * If within cooldown period received another message of the same category, it
- * is not published, but counter is increased with addition of some entity identifier
- *
- * 2. There is no background task running. In order to keep relevance of logs,
- * if after certain amount of time we didn't receive logs, then we discarded accumulated ones
- * on the next received ones and only publish relevant ones
- */
-
-export class LogMessagesSuppressor<T extends StandardStringEnum> {
-  // I don't really like this any, but couldn't come up with better solution
-  // in reasonable time. So, in order to unblock myself, do this
-  static instances: Record<string, LogMessagesSuppressor<any>> = {};
-
-  private _aggregatedLogs: AggregatedLogForEntity<T> = {};
-
-  constructor(
-    readonly entityName: string,
-    private _allMessages: Record<keyof T, MessageInfo<T>>,
-    protected logger: Logger,
-  ) {}
-
-  static getLogSuppressorInstance<T extends StandardStringEnum>(
-    entityName: string,
-    allMessages: Record<keyof T, MessageInfo<T>>,
-    logger: Logger,
-  ) {
-    const instance = LogMessagesSuppressor.instances[entityName];
-    if (instance === undefined) {
-      LogMessagesSuppressor.instances[entityName] =
-        new LogMessagesSuppressor<T>(entityName, allMessages, logger);
-    } else {
-      assert(
-        _.isEqual(allMessages, instance._allMessages),
-        'getLogSuppressorInstance: try to get existing instance with different allMessagesInfo',
-      );
-      assert(
-        _.isEqual(logger, instance.logger),
-        'getLogSuppressorInstance: try to get existing instance with different logger',
-      );
-    }
-    return LogMessagesSuppressor.instances[entityName];
-  }
-
-  logMessage(
-    msgKey: keyof T,
-    identificationInfo: string = '',
-    ...args: unknown[]
-  ) {
-    const msgInfo = this._allMessages[msgKey];
-    assert(
-      msgInfo !== undefined,
-      `Used unrecognized msgKey=${String(msgKey)} to get msgInfo`,
-    );
-
-    if (this._aggregatedLogs[msgKey] === undefined) {
-      this._aggregatedLogs[msgKey] = {
-        counter: 0,
-        identificationInfos:
-          identificationInfo === '' ? [] : [identificationInfo],
-        lastLoggedAtMs: 0,
-      };
-    }
-    const msgData = this._aggregatedLogs[msgKey];
-    assert(
-      msgData !== undefined,
-      `msgData is undefined for msgKey=${String(msgKey)}`,
-    );
-
-    const nowMs = Date.now();
-
-    const elapsedSinceLastPublish = nowMs - msgData.lastLoggedAtMs;
-
-    if (elapsedSinceLastPublish > DEFAULT_LOG_PUBLISH_PERIOD_MS) {
-      // Accumulated logs are too old to have any relevance, so better to discard them
-      if (elapsedSinceLastPublish > DEFAULT_LOG_DISCARD_PERIOD_MS) {
-        this._clearMessageData(msgData);
-      }
-
-      // Make actual logging
-      // Logging is done using original logger of the entity to keep module info
-      // and not override it
-      const formattedMessage = this._formatLogMessage(
-        msgData,
-        msgInfo.message,
-        args,
-      );
-      this.logger[msgInfo.logLevel](formattedMessage);
-      this._clearMessageData(msgData);
-    } else {
-      msgData.counter++;
-      if (identificationInfo !== '') {
-        msgData.identificationInfos.push(identificationInfo);
-      }
-    }
-  }
-
-  private _formatLogMessage(
-    msgData: MessageData,
-    message: string,
-    args: unknown[],
-  ) {
-    const { counter, identificationInfos } = msgData;
-    let identities =
-      identificationInfos && identificationInfos.length === 0
-        ? ''
-        : ` for entities: ${
-            identificationInfos.length > DEFAULT_LOG_MAX_IDENTITIES_TO_SHOW
-              ? identificationInfos
-                  .slice(DEFAULT_LOG_MAX_IDENTITIES_TO_SHOW)
-                  .join(',')
-              : identificationInfos.join(',')
-          }`;
-
-    if (
-      identificationInfos &&
-      identificationInfos.length > DEFAULT_LOG_MAX_IDENTITIES_TO_SHOW
-    ) {
-      identities = `${identities}... ${identificationInfos.length} total`;
-    }
-    const argsFormatted =
-      args.length > 0
-        ? ` with args: ${args.map(a => Utils.Serialize(a)).join('.')}`
-        : '';
-    return `Logged ${counter} occurrences of: "${message}"${identities}${argsFormatted}`;
-  }
-
-  private _clearMessageData(messageData: MessageData) {
-    messageData.counter = 0;
-    if (messageData.identificationInfos) {
-      messageData.identificationInfos.length = 0;
-    }
-    messageData.lastLoggedAtMs = Date.now();
-  }
-}

package/src/lib/stateful-rpc-poller/state-polling-manager.ts

@@ -1,320 +0,0 @@
-import _ from 'lodash';
-import { assert } from 'console';
-import { IDexHelper } from '../../dex-helper';
-import { Logger } from '../../types';
-import { MultiResult } from '../multi-wrapper';
-import { IStatefulRpcPoller } from './types';
-
-export class StatePollingManager {
-  // This is for update pool states function. If we see state for new block and
-  // the diff is bigger than this number, than something might be wrong and
-  // we warn about this
-  static readonly DEFAULT_BLOCK_NUMBER_DIFFERENCE_TO_ALERT = 10;
-
-  private static __instances: Record<string, StatePollingManager> = {};
-
-  static getInstance(dexHelper: IDexHelper): StatePollingManager {
-    const network = dexHelper.config.data.network;
-    if (StatePollingManager.__instances[network] === undefined) {
-      StatePollingManager.__instances[network] = new StatePollingManager(
-        dexHelper,
-      );
-    }
-    return StatePollingManager.__instances[network];
-  }
-
-  private _lastProcessedBlockNumber = 0;
-
-  private logger: Logger;
-
-  private _registeredPendingPools: IStatefulRpcPoller<any, any>[] = [];
-
-  // ALl registered instances from identifier to instance
-  private _poolsToInstances: Record<string, IStatefulRpcPoller<any, any>> = {};
-
-  // This pools will be updated if we see new block and the time has come
-  private _poolsToBeUpdated: Set<string> = new Set();
-
-  // This pools wont be updated before we change _isStateToBeUpdated to true
-  private _idlePools: Set<string> = new Set();
-
-  private constructor(protected dexHelper: IDexHelper) {
-    this.logger = this.dexHelper.getLogger(
-      `${this.constructor.name}-${dexHelper.config.data.network}`,
-    );
-  }
-
-  get isMaster() {
-    return !this.dexHelper.config.isSlave;
-  }
-
-  enableStateTracking(identifierKey: string) {
-    assert(
-      this._poolsToInstances[identifierKey] !== undefined,
-      `enableTracking: pool with identifierKey=${identifierKey} is not initialized`,
-    );
-    this._poolsToBeUpdated.add(identifierKey);
-    this._idlePools.delete(identifierKey);
-  }
-
-  disableStateTracking(identifierKey: string) {
-    assert(
-      this._poolsToInstances[identifierKey] !== undefined,
-      `disableStateTracking: pool with identifierKey=${identifierKey} is not initialized`,
-    );
-    this._poolsToBeUpdated.delete(identifierKey);
-    this._idlePools.add(identifierKey);
-  }
-
-  async onBlockNumber(blockNumber: number): Promise<void> {
-    if (!this.isMaster) {
-      return;
-    }
-
-    // Events-client calls several times for the same blockNumber sometimes
-    // I want to filter them. The only condition, that matters is that blockNumbers are the same
-    if (this._lastProcessedBlockNumber === blockNumber) {
-      return;
-    }
-    this._lastProcessedBlockNumber = blockNumber;
-
-    const poolsToBeUpdated: IStatefulRpcPoller<any, any>[] = [];
-
-    Array.from(this._poolsToBeUpdated).forEach(p => {
-      const pool = this._keyToPoolInstance(p);
-
-      // We always expect pools in _poolsToBeUpdated to participate in updates
-      assert(
-        pool.isPoolParticipateInUpdates,
-        `onBlockNumber: pool=${p} from ${pool.dexKey} is not participate in updates`,
-      );
-
-      if (
-        !pool.isPoolInTheMiddleOfUpdate &&
-        pool.isTimeToTriggerUpdate(blockNumber)
-      ) {
-        pool.isPoolInTheMiddleOfUpdate = true;
-        poolsToBeUpdated.push(pool);
-      }
-    });
-
-    if (poolsToBeUpdated.length === 0) {
-      this.logger.debug(
-        `onBlockNumber=${blockNumber} no pools to be updated. Skipping`,
-      );
-      return;
-    }
-
-    this._updatePoolStates(poolsToBeUpdated)
-      .then(receivedBlockNumber => {
-        // There is no guarantee that we receive latest state. This is our best effort
-        if (
-          Math.abs(blockNumber - receivedBlockNumber) >
-          StatePollingManager.DEFAULT_BLOCK_NUMBER_DIFFERENCE_TO_ALERT
-        ) {
-          this.logger.warn(
-            `onBlockNumber=${blockNumber} at least for some pools receivedBlockNumber=${receivedBlockNumber} is lower than expected`,
-          );
-        }
-        this.logger.info(
-          `onBlockNumber=${blockNumber} updated ${
-            poolsToBeUpdated.length
-          } pools: ${poolsToBeUpdated
-            .map(p => p.identifierKey)
-            .slice(0, 10)
-            .join(',')} (sample)`,
-        );
-      })
-      .catch(e =>
-        this.logger.error(
-          `onBlockNumber=${blockNumber} error while updating pools: ${e}`,
-        ),
-      )
-      .finally(() => {
-        poolsToBeUpdated.forEach(pool => {
-          pool.isPoolInTheMiddleOfUpdate = false;
-        });
-      });
-  }
-
-  protected async _updatePoolStates(
-    poolsToBeUpdated: IStatefulRpcPoller<any, any>[],
-    blockNumber: number | 'latest' = 'latest',
-    numberOfChunks?: number,
-  ): Promise<number> {
-    const indexDividers: number[] = [];
-
-    const multiCalls = poolsToBeUpdated
-      .map((p, i) => {
-        const callData = p.getFetchStateWithBlockInfoMultiCalls();
-        indexDividers.push(callData.length);
-        return callData;
-      })
-      .flat();
-
-    assert(
-      indexDividers.length === poolsToBeUpdated.length,
-      'indexDividers.length === poolsToBeUpdated.length',
-    );
-
-    const results = (await this.dexHelper.multiWrapper.tryAggregate(
-      false,
-      multiCalls,
-      blockNumber,
-      numberOfChunks,
-    )) as [MultiResult<number>, ...MultiResult<any>[]];
-
-    let minBlockNumber = 0;
-    const lastUpdatedAtMs = Date.now();
-
-    // Let's pack each result into relevant pools
-    const unFlattenedResults: [MultiResult<number>, ...MultiResult<any>[]][] =
-      [];
-
-    let accumulatedStart = 0;
-    indexDividers.forEach(divider => {
-      unFlattenedResults.push(
-        results.slice(accumulatedStart, accumulatedStart + divider) as [
-          MultiResult<number>,
-          ...MultiResult<any>[],
-        ],
-      );
-      accumulatedStart += divider;
-    });
-
-    assert(
-      unFlattenedResults.length === poolsToBeUpdated.length,
-      'unFlattenedResults.length === poolsToBeUpdated.length',
-    );
-
-    await Promise.all(
-      unFlattenedResults.map(async (result, index) => {
-        const pool = poolsToBeUpdated[index];
-        try {
-          const parsedStateResult =
-            pool.parseStateFromMultiResultsWithBlockInfo(
-              result,
-              lastUpdatedAtMs,
-            );
-
-          minBlockNumber =
-            minBlockNumber === 0
-              ? parsedStateResult.blockNumber
-              : Math.min(parsedStateResult.blockNumber, minBlockNumber);
-
-          await pool.setState(
-            parsedStateResult.value,
-            parsedStateResult.blockNumber,
-            parsedStateResult.lastUpdatedAtMs,
-          );
-        } catch (e) {
-          this.logger.error(
-            `onBlockNumber=${blockNumber} error while parsing state from multicall for pool=${pool.identifierKey} from ${pool.dexKey}: ${e}`,
-          );
-        }
-      }),
-    );
-
-    return minBlockNumber;
-  }
-
-  // When this method is called, we expect that all pools are initialized
-  private _keyToPoolInstance(
-    identifierKey: string,
-  ): IStatefulRpcPoller<any, any> {
-    const pool = this._poolsToInstances[identifierKey];
-    assert(
-      pool !== undefined,
-      `keyToPoolInstance: pool=${identifierKey} is undefined`,
-    );
-    return pool;
-  }
-
-  // Once you instantiated all your pools, you should trigger at the end of initializing this method
-  // So all state will be initialized. It is not part of constructor, because and that time we don't have
-  // all classes built
-  initializeAllPendingPools() {
-    if (this._registeredPendingPools.length === 0) {
-      return;
-    }
-
-    this._registeredPendingPools.forEach(p => {
-      this.initializePool(p);
-    });
-
-    this._registeredPendingPools = [];
-  }
-
-  registerPendingPool<T, M>(statefulRpcPoller: IStatefulRpcPoller<T, M>) {
-    if (this._poolsToInstances[statefulRpcPoller.identifierKey]) {
-      this.logger.error(
-        `Attempt to register initialized pool=${statefulRpcPoller.identifierKey}`,
-      );
-      return;
-    }
-
-    const alreadyRegisteredAsPending = this._registeredPendingPools.some(
-      p => p.identifierKey === statefulRpcPoller.identifierKey,
-    );
-    if (alreadyRegisteredAsPending) {
-      this.logger.error(
-        `Attempt to register pool=${statefulRpcPoller.identifierKey} twice`,
-      );
-      return;
-    }
-    this._registeredPendingPools.push(statefulRpcPoller);
-  }
-
-  async initializePool<T, M>(statefulRpcPoller: IStatefulRpcPoller<T, M>) {
-    const { identifierKey } = statefulRpcPoller;
-
-    if (
-      this._idlePools.has(identifierKey) ||
-      this._poolsToBeUpdated.has(identifierKey) ||
-      this._poolsToInstances.hasOwnProperty(identifierKey)
-    ) {
-      this.logger.warn(
-        `Attempt to reinitialize existing poolIdentifier=` +
-          `${identifierKey}. Maybe there is memory leak`,
-      );
-    } else {
-      this._poolsToInstances[identifierKey] = statefulRpcPoller;
-      statefulRpcPoller.isPoolParticipateInUpdates
-        ? this._poolsToBeUpdated.add(identifierKey)
-        : this._idlePools.add(identifierKey);
-
-      let currentBlockNumber: number | undefined;
-      // This complication is only for pool tracker. We don't have block manager there and
-      // this is workaround to get current block number
-      if (
-        this.dexHelper.blockManager &&
-        this.dexHelper.blockManager.getActiveChainHead
-      ) {
-        currentBlockNumber =
-          this.dexHelper.blockManager.getActiveChainHead()?.number;
-      }
-
-      if (currentBlockNumber === undefined) {
-        currentBlockNumber =
-          await this.dexHelper.web3Provider.eth.getBlockNumber();
-      }
-
-      assert(
-        currentBlockNumber !== undefined,
-        'currentBlockNumber !== undefined',
-      );
-
-      statefulRpcPoller
-        .initializeState()
-        .then(() => {
-          this.logger.info(`Successfully initialized pool=${identifierKey}`);
-        })
-        .catch(e => {
-          // Must never happen
-          this.logger.error(
-            `initializePool: pool=${identifierKey} from ${statefulRpcPoller.dexKey} error while initializing state: ${e}`,
-          );
-        });
-    }
-  }
-}