@paraswap/dex-lib 2.14.0 → 2.14.2

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

@@ -0,0 +1,487 @@
+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/decoders.ts

@@ -28,12 +28,15 @@ export const extractSuccessAndValue = (
 export function generalDecoder<T>(
   result: MultiResult<BytesLike> | BytesLike,
   types: string[],
-  defaultValue: T,
+  defaultValue: T | undefined,
   parser?: (v: Result) => T,
 ): T {
   const [isSuccess, toDecode] = extractSuccessAndValue(result);
 
   if (!isSuccess || toDecode === '0x') {
+    if (defaultValue === undefined) {
+      throw new Error(`Failed to decode result: ${result}`);
+    }
     return defaultValue;
   }
 
@@ -136,6 +139,14 @@ export const addressDecode = (
   );
 };
 
+export const addressArrayDecode = (
+  result: MultiResult<BytesLike> | BytesLike,
+): string => {
+  return generalDecoder(result, ['address[]'], [], v =>
+    v[0].map((a: string) => a.toLowerCase()),
+  );
+};
+
 export const stringDecode = (
   result: MultiResult<BytesLike> | BytesLike,
 ): string => {

package/src/lib/fetcher/fetcher.ts

@@ -76,6 +76,12 @@ export default class Fetcher<T> {
       .map((_, i) => i)
       .filter(i => results[i] instanceof Error);
 
+    results.map(result => {
+      this.logger.info(
+        'Results Data:',
+        JSON.stringify((result as any).data, null, 4).substring(0, 500),
+      );
+    });
     failures.forEach(i => {
       this.logger.warn(
         `failed polling ${this.requests[i].info.requestOptions.url} ${results[i]}`,

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

@@ -0,0 +1,173 @@
+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();
+  }
+}