@paraswap/dex-lib 2.13.0 → 2.14.0

package/src/dex/woo-fi-v2/woo-fi-v2.ts

@@ -1,487 +0,0 @@
-import {
-  Token,
-  Address,
-  ExchangePrices,
-  PoolPrices,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
-  Logger,
-} from '../../types';
-import { SwapSide, Network, NULL_ADDRESS } from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
-import { IDex } from '../../dex/idex';
-import { addressArrayDecode, uint8ToNumber } from '../../lib/decoders';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { WooFiV2Data, DexParams } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { WooFiV2Config, Adapters } from './config';
-import { WooFiV2PollingPool } from './woo-fi-v2-pool';
-import { WooFiV2Math } from './woo-fi-v2-math';
-import { MIN_CONVERSION_RATE, WOO_FI_V2_GAS_COST } from './constants';
-import { assert } from 'ts-essentials';
-import { ethers } from 'ethers';
-import { addressDecode } from '../../lib/decoders';
-import { ifaces } from './utils';
-import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
-
-export class WooFiV2 extends SimpleExchange implements IDex<WooFiV2Data> {
-  readonly math: WooFiV2Math;
-
-  protected pollingManager: StatePollingManager;
-
-  protected pollingPool?: WooFiV2PollingPool;
-
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = true;
-
-  readonly isFeeOnTransferSupported = false;
-
-  readonly isStatePollingDex = true;
-
-  readonly quoteTokenAddress: Address;
-
-  protected _baseTokens?: Token[];
-
-  // Since exchange anyways takes fee, we provide our fee wallet
-  // to take part of that fee and move to DAO
-  protected rebateTo?: Address;
-
-  tokenByAddress?: Record<Address, Token>;
-
-  vaultUSDBalance: number = 0;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(WooFiV2Config);
-
-  logger: Logger;
-
-  constructor(
-    protected network: Network,
-    dexKey: string,
-    readonly dexHelper: IDexHelper,
-    protected adapters = Adapters[network] || {},
-    readonly config = WooFiV2Config[dexKey][network],
-  ) {
-    super(dexHelper, dexKey);
-    const loggerName = `${dexKey}-${network}`;
-    this.logger = dexHelper.getLogger(loggerName);
-
-    // Normalise once all config addresses and use across all scenarios
-    this.config = this._toLowerForAllConfigAddresses();
-
-    this.quoteTokenAddress = this.config.quoteToken.address;
-
-    // Do not do it singleton, because different networks will have different
-    // states at the same time
-    this.math = new WooFiV2Math(
-      dexHelper.getLogger(`${loggerName}_math`),
-      this.quoteTokenAddress,
-    );
-    this.pollingManager = StatePollingManager.getInstance(dexHelper);
-  }
-
-  private _toLowerForAllConfigAddresses() {
-    // If new config property will be added, the TS will throw compile error
-    const newConfig: DexParams = {
-      wooPPV2Address: this.config.wooPPV2Address.toLowerCase(),
-      wooOracleV2Address: this.config.wooOracleV2Address.toLowerCase(),
-      integrationHelperAddress:
-        this.config.integrationHelperAddress.toLowerCase(),
-      quoteToken: {
-        ...this.config.quoteToken,
-        address: this.config.quoteToken.address.toLowerCase(),
-      },
-    };
-    return newConfig;
-  }
-
-  get baseTokens(): Token[] {
-    if (!this._baseTokens) {
-      throw new Error(
-        `Base tokens are not set for ${this.dexKey}-${this.network}. Not properly initialized`,
-      );
-    }
-    return this._baseTokens;
-  }
-
-  async initializePricing(blockNumber: number) {
-    await this.initializeTokensAndAddresses();
-    this._initializePollingPool();
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return this.adapters[side] ? this.adapters[side] : null;
-  }
-
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    if (side === SwapSide.BUY) return [];
-
-    if (this.tokenByAddress === undefined) {
-      this.logger.error(`tokenByAddress is undefined in getPoolIdentifiers`);
-      return [];
-    }
-
-    const _srcToken = this.dexHelper.config.wrapETH(srcToken);
-    const _destToken = this.dexHelper.config.wrapETH(destToken);
-
-    const _srcAddress = _srcToken.address.toLowerCase();
-    const _destAddress = _destToken.address.toLowerCase();
-
-    if (_srcAddress === _destAddress) return [];
-
-    if (
-      !this.tokenByAddress[_srcAddress] ||
-      !this.tokenByAddress[_destAddress]
-    ) {
-      return [];
-    }
-
-    return [this.getIdentifier()];
-  }
-
-  getIdentifier() {
-    return `${this.dexKey}_wooppv2`;
-  }
-
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<WooFiV2Data>> {
-    if (side === SwapSide.BUY) return null;
-
-    try {
-      if (this.tokenByAddress === undefined) {
-        this.logger.error(`tokenByAddress is undefined in getPricesVolume`);
-        return null;
-      }
-
-      const _srcToken = this.dexHelper.config.wrapETH(srcToken);
-      const _destToken = this.dexHelper.config.wrapETH(destToken);
-
-      const _srcAddress = _srcToken.address.toLowerCase();
-      const _destAddress = _destToken.address.toLowerCase();
-
-      if (_srcAddress === _destAddress) return null;
-
-      if (
-        !this.tokenByAddress[_srcAddress] ||
-        !this.tokenByAddress[_destAddress]
-      )
-        return null;
-
-      const expectedIdentifier = this.getIdentifier();
-
-      if (
-        limitPools !== undefined &&
-        !limitPools.some(p => p === expectedIdentifier)
-      )
-        return null;
-
-      const unitVolume = getBigIntPow(_srcToken.decimals);
-
-      const _amounts = [unitVolume, ...amounts.slice(1)];
-
-      assert(
-        this.pollingPool,
-        'pollingPool is not initialized in getPricesVolume',
-      );
-
-      const state = await this.pollingPool.getState(blockNumber);
-
-      if (state === null) {
-        this.logger.error(`State is null in getPricesVolume`);
-        return null;
-      }
-
-      if (state.value.isPaused) {
-        this.logger.warn(
-          `${this.dexKey} is paused on ${this.network} in getPricesVolume`,
-        );
-        return null;
-      }
-
-      this.math.state = state.value;
-
-      const _prices = this.math.query(_srcAddress, _destAddress, _amounts);
-
-      if (!_prices) return null;
-
-      const unit = _prices[0];
-
-      let gasCost = WOO_FI_V2_GAS_COST.baseToBase;
-      if (_srcAddress === this.config.quoteToken.address) {
-        gasCost = WOO_FI_V2_GAS_COST.sellQuote;
-      } else if (_destAddress === this.config.quoteToken.address) {
-        gasCost = WOO_FI_V2_GAS_COST.sellBase;
-      } else {
-        this.logger.error(
-          `Can not estimate gas cost in getPricesVolume. Check the logic: ` +
-            `${_srcAddress}, ${_destAddress}, ${this.config.quoteToken.address}`,
-        );
-      }
-
-      return [
-        {
-          unit,
-          prices: [0n, ..._prices.slice(1)],
-          data: {},
-          poolIdentifier: expectedIdentifier,
-          exchange: this.dexKey,
-          gasCost,
-          poolAddresses: [this.config.wooPPV2Address],
-        },
-      ];
-    } catch (e) {
-      this.logger.error(
-        `Error_getPricesVolume ${srcToken.symbol || srcToken.address}, ${
-          destToken.symbol || destToken.address
-        }, ${side}:`,
-        e,
-      );
-      return null;
-    }
-  }
-
-  getCalldataGasCost(poolPrices: PoolPrices<WooFiV2Data>): number | number[] {
-    return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.ADDRESS;
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: WooFiV2Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    let rebateTo = this.rebateTo;
-    if (rebateTo === undefined) {
-      this.logger.error(`rebateTo is undefined in getAdapterParam`);
-      rebateTo = NULL_ADDRESS;
-    }
-
-    const payload = this.abiCoder.encodeParameter('address', rebateTo);
-
-    return {
-      targetExchange: this.config.wooPPV2Address,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: WooFiV2Data,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const _srcToken = srcToken.toLowerCase();
-    const _destToken = destToken.toLowerCase();
-
-    let rebateTo = this.rebateTo;
-    if (rebateTo === undefined) {
-      this.logger.error(`rebateTo is undefined in getAdapterParam`);
-      rebateTo = NULL_ADDRESS;
-    }
-
-    const swapData = ifaces.PPV2.encodeFunctionData('swap', [
-      _srcToken,
-      _destToken,
-      srcAmount,
-      MIN_CONVERSION_RATE,
-      this.augustusAddress,
-      rebateTo,
-    ]);
-
-    const transferParams = this.erc20Interface.encodeFunctionData('transfer', [
-      this.config.wooPPV2Address,
-      srcAmount,
-    ]);
-
-    return {
-      callees: [srcToken, this.config.wooPPV2Address],
-      calldata: [transferParams, swapData],
-      values: ['0', '0'],
-      networkFee: '0',
-    };
-  }
-
-  async updatePoolState(): Promise<void> {
-    if (this._baseTokens === undefined || this.tokenByAddress === undefined) {
-      await this.initializeTokensAndAddresses();
-    }
-    if (this.pollingPool === undefined) {
-      this._initializePollingPool();
-    }
-
-    if (this.tokenByAddress === undefined) {
-      this.logger.error(`tokenByAddress is undefined in updatePoolState`);
-      return;
-    }
-
-    assert(
-      this.pollingPool,
-      'pollingPool is not initialized in updatePoolState',
-    );
-    const state = await this.pollingPool.getState();
-
-    if (!state) {
-      this.logger.error(
-        `Failed to updatePoolState. State is null. VaultUSDBalance: ${this.vaultUSDBalance} was not updated`,
-      );
-      return;
-    }
-
-    const tokenBalancesUSD = await Promise.all(
-      Object.values(this.tokenByAddress).map(t =>
-        this.dexHelper.getTokenUSDPrice(
-          t,
-          state.value.tokenInfos[t.address].reserve,
-        ),
-      ),
-    );
-    this.vaultUSDBalance = tokenBalancesUSD.reduce(
-      (sum: number, curr: number) => sum + curr,
-    );
-  }
-
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    const wrappedTokenAddress = this.dexHelper.config
-      .wrapETH({ address: tokenAddress, decimals: 0 })
-      .address.toLowerCase();
-
-    if (this.tokenByAddress === undefined) {
-      this.logger.error(`tokenByAddress is undefined in getTopPoolsForToken`);
-      return [];
-    }
-
-    if (!this.tokenByAddress[wrappedTokenAddress]) return [];
-
-    assert(
-      this.pollingPool,
-      'pollingPool is not initialized in getTopPoolsForToken',
-    );
-    const latestState = await this.pollingPool.getState();
-    if (!latestState) return [];
-
-    if (latestState.value.isPaused) {
-      this.logger.warn(`Paused on ${this.network} in getTopPoolsForToken`);
-      return [];
-    }
-
-    const connectorTokens = Object.values(this.tokenByAddress).filter(
-      t => t.address !== wrappedTokenAddress,
-    );
-
-    return [
-      {
-        exchange: this.dexKey,
-        address: this.config.wooPPV2Address,
-        connectorTokens,
-        liquidityUSD: this.vaultUSDBalance,
-      },
-    ];
-  }
-
-  private _initializeTokenByAddress(baseTokens: Token[]) {
-    this.tokenByAddress = baseTokens.reduce(
-      (acc, cur) => {
-        acc[cur.address] = cur;
-        return acc;
-      },
-      { [this.quoteTokenAddress]: this.config.quoteToken },
-    );
-  }
-
-  async _fetchBaseTokensAndFeeWallet(): Promise<Address[]> {
-    return (
-      await this.dexHelper.multiWrapper.aggregate([
-        {
-          target: this.augustusAddress,
-          callData: this.augustusInterface.encodeFunctionData(
-            'getFeeWallet',
-            [],
-          ),
-          decodeFunction: addressDecode,
-        },
-        {
-          target: this.config.integrationHelperAddress,
-          callData:
-            ifaces.integrationHelper.encodeFunctionData('allBaseTokens'),
-          decodeFunction: addressArrayDecode,
-        },
-      ])
-    ).flat();
-  }
-
-  async _fetchDecimals(baseTokenAddresses: Address[]): Promise<number[]> {
-    return this.dexHelper.multiWrapper.aggregate(
-      baseTokenAddresses.map(address => {
-        return {
-          target: address,
-          callData: this.erc20Interface.encodeFunctionData('decimals'),
-          decodeFunction: uint8ToNumber,
-        };
-      }),
-    );
-  }
-
-  async initializeTokensAndAddresses() {
-    const [rebateTo, ...baseTokenAddresses] =
-      await this._fetchBaseTokensAndFeeWallet();
-
-    assert(ethers.utils.isAddress(rebateTo), 'Invalid rebateTo address');
-
-    this.rebateTo = rebateTo;
-    const decimals = await this._fetchDecimals(baseTokenAddresses);
-
-    assert(
-      decimals.length === baseTokenAddresses.length,
-      'Decimals length mismatch',
-    );
-
-    this._baseTokens = baseTokenAddresses.reduce<Token[]>((acc, curr, i) => {
-      acc.push({
-        address: curr,
-        decimals: decimals[i],
-      });
-      return acc;
-    }, []);
-
-    this._initializeTokenByAddress(this.baseTokens);
-  }
-
-  private _initializePollingPool() {
-    assert(this.tokenByAddress, 'tokenByAddress is not properly');
-
-    this.pollingPool = new WooFiV2PollingPool(
-      this.dexKey,
-      this.getIdentifier(),
-      this.dexHelper,
-      this.config,
-      Object.values(this.tokenByAddress),
-    );
-
-    this.pollingManager.initializeAllPendingPools();
-  }
-}

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();
-  }
-}