@paraswap/dex-lib 4.1.20 → 4.1.21

package/src/lib/chainlink.ts

@@ -1,113 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { PartialEventSubscriber } from '../composed-event-subscriber';
-import {
-  Address,
-  BlockHeader,
-  Log,
-  Logger,
-  MultiCallInput,
-  MultiCallOutput,
-} from '../types';
-import { Lens } from '../lens';
-import { Interface } from '@ethersproject/abi';
-import ProxyABI from '../abi/chainlink.json';
-
-export type ChainLinkState = {
-  answer: bigint;
-  timestamp: bigint;
-};
-
-export class ChainLinkSubscriber<State> extends PartialEventSubscriber<
-  State,
-  ChainLinkState
-> {
-  static readonly proxyInterface = new Interface(ProxyABI);
-  static readonly ANSWER_UPDATED_TOPIC =
-    ChainLinkSubscriber.proxyInterface.getEventTopic('AnswerUpdated');
-
-  constructor(
-    private proxy: Address,
-    private aggregator: Address,
-    lens: Lens<DeepReadonly<State>, DeepReadonly<ChainLinkState>>,
-    logger: Logger,
-  ) {
-    super([aggregator], lens, logger);
-  }
-
-  static getReadAggregatorMultiCallInput(proxy: Address): MultiCallInput {
-    return {
-      target: proxy,
-      callData:
-        ChainLinkSubscriber.proxyInterface.encodeFunctionData('aggregator'),
-    };
-  }
-
-  static readAggregator(multicallOutput: MultiCallOutput): Address {
-    return ChainLinkSubscriber.proxyInterface.decodeFunctionResult(
-      'aggregator',
-      multicallOutput,
-    )[0];
-  }
-
-  static getReadDecimal(proxy: Address): MultiCallInput {
-    return {
-      target: proxy,
-      callData:
-        ChainLinkSubscriber.proxyInterface.encodeFunctionData('decimals'),
-    };
-  }
-
-  static readDecimals(multicallOutput: MultiCallOutput): Address {
-    return ChainLinkSubscriber.proxyInterface.decodeFunctionResult(
-      'decimals',
-      multicallOutput,
-    )[0];
-  }
-
-  public processLog(
-    state: DeepReadonly<ChainLinkState>,
-    log: Readonly<Log>,
-    blockHeader: Readonly<BlockHeader>,
-  ): DeepReadonly<ChainLinkState> | null {
-    if (log.topics[0] !== ChainLinkSubscriber.ANSWER_UPDATED_TOPIC) return null; // Ignore other events
-    const decoded = ChainLinkSubscriber.proxyInterface.decodeEventLog(
-      'AnswerUpdated',
-      log.data,
-      log.topics,
-    );
-    return {
-      answer: BigInt(decoded.current.toString()),
-      timestamp: BigInt(decoded.updatedAt.toString()),
-    };
-  }
-
-  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
-    return [
-      {
-        target: this.proxy,
-        callData:
-          ChainLinkSubscriber.proxyInterface.encodeFunctionData(
-            'latestRoundData',
-          ),
-      },
-    ];
-  }
-
-  public generateState(
-    multicallOutputs: MultiCallOutput[],
-    blockNumber?: number | 'latest',
-  ): DeepReadonly<ChainLinkState> {
-    const decoded = ChainLinkSubscriber.proxyInterface.decodeFunctionResult(
-      'latestRoundData',
-      multicallOutputs[0],
-    );
-    return {
-      answer: BigInt(decoded.answer.toString()),
-      timestamp: BigInt(decoded.updatedAt.toString()),
-    };
-  }
-
-  public getLatestRoundData(state: DeepReadonly<State>): bigint {
-    return this.lens.get()(state).answer;
-  }
-}

package/src/lib/curve/encoder.ts

@@ -1,19 +0,0 @@
-import { Address } from '@paraswap/core';
-import { BigNumber } from 'ethers';
-import { CurveV1SwapType } from '../../dex/curve-v1/types';
-import { CurveV2SwapType } from '../../dex/curve-v2/types';
-
-export const packCurveData = (
-  address: Address,
-  approve: boolean,
-  wrapFlag: number,
-  swapType: CurveV2SwapType | CurveV1SwapType,
-): BigNumber => {
-  let packedData = BigNumber.from(address);
-
-  packedData = packedData.or(BigNumber.from(approve ? 1 : 0).shl(160));
-  packedData = packedData.or(BigNumber.from(wrapFlag).shl(161));
-  packedData = packedData.or(BigNumber.from(swapType).shl(163));
-
-  return packedData;
-};

package/src/lib/decoders.ts

@@ -1,199 +0,0 @@
-import { Result } from '@ethersproject/abi';
-import BigNumber from 'bignumber.js';
-import { BigNumber as EthersBigNumber } from 'ethers';
-import { BytesLike, defaultAbiCoder } from 'ethers/lib/utils';
-import _, { parseInt } from 'lodash';
-import { BN_0 } from '../bignumber-constants';
-import { NULL_ADDRESS } from '../constants';
-import { MultiResult } from './multi-wrapper';
-
-const isMultiResult = (
-  result: MultiResult<BytesLike> | BytesLike,
-): result is MultiResult<BytesLike> => {
-  return (
-    typeof result === 'object' &&
-    result !== null &&
-    'success' in result &&
-    'returnData' in result
-  );
-};
-
-export const extractSuccessAndValue = (
-  result: MultiResult<BytesLike> | BytesLike,
-): [boolean, BytesLike] => {
-  return isMultiResult(result)
-    ? [result.success, result.returnData]
-    : [true, result];
-};
-
-export function generalDecoder<T>(
-  result: MultiResult<BytesLike> | BytesLike,
-  types: string[],
-  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;
-  }
-
-  const decoded = defaultAbiCoder.decode(types, toDecode);
-  return parser ? parser(decoded) : decoded[0];
-}
-
-export const uint256ToBigInt = (
-  result: MultiResult<BytesLike> | BytesLike,
-): bigint => {
-  return generalDecoder(result, ['uint256'], 0n, value => value[0].toBigInt());
-};
-
-export const uint128ToBigNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): EthersBigNumber => {
-  return generalDecoder(result, ['uint128'], 0n, value => value[0]);
-};
-
-export const int24ToNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  return generalDecoder(result, ['int24'], 0n, value => value[0]);
-};
-
-export const uint256ArrayDecode = (
-  result: MultiResult<BytesLike> | BytesLike,
-): bigint => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return 0n;
-  }
-  return defaultAbiCoder
-    .decode(['uint256[]'], toDecode)[0]
-    .map((r: any) => r.toBigInt());
-};
-
-export const uin256DecodeToBigNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): BigNumber => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return BN_0;
-  }
-  return new BigNumber(
-    defaultAbiCoder.decode(['uint256'], toDecode)[0].toString(),
-  );
-};
-
-export const uint256DecodeToNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return 0;
-  }
-  return parseInt(defaultAbiCoder.decode(['uint256'], toDecode)[0], 10);
-};
-
-export const uin256DecodeToFloat = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return 0;
-  }
-  return parseFloat(defaultAbiCoder.decode(['uint256'], toDecode)[0]);
-};
-
-export const uin128DecodeToFloat = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return 0;
-  }
-  return parseFloat(defaultAbiCoder.decode(['uint128'], toDecode)[0]);
-};
-
-export const uin128DecodeToInt = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return 0;
-  }
-  return parseInt(defaultAbiCoder.decode(['uint128'], toDecode)[0], 10);
-};
-
-export const booleanDecode = (
-  result: MultiResult<BytesLike> | BytesLike,
-): boolean => {
-  const [isSuccess, toDecode] = extractSuccessAndValue(result);
-
-  if (!isSuccess) {
-    return false;
-  }
-  return defaultAbiCoder.decode(['bool'], toDecode)[0];
-};
-
-export const addressDecode = (
-  result: MultiResult<BytesLike> | BytesLike,
-): string => {
-  return generalDecoder(result, ['address'], NULL_ADDRESS, v =>
-    v[0].toLowerCase(),
-  );
-};
-
-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 => {
-  return generalDecoder(result, ['string'], '');
-};
-
-export const bytes32ToString = (
-  result: MultiResult<BytesLike> | BytesLike,
-): string => {
-  return generalDecoder(result, ['bytes32'], '', value =>
-    value[0].toLowerCase(),
-  );
-};
-
-export const uint8ToNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  return generalDecoder(result, ['uint8'], 0, value =>
-    parseInt(value[0].toString(), 10),
-  );
-};
-
-export const uint24ToNumber = (
-  result: MultiResult<BytesLike> | BytesLike,
-): number => {
-  return generalDecoder(result, ['uint24'], 0, value =>
-    parseInt(value[0].toString(), 10),
-  );
-};
-
-export const uint24ToBigInt = (
-  result: MultiResult<BytesLike> | BytesLike,
-): bigint => {
-  return generalDecoder(result, ['uint24'], 0n, value =>
-    BigInt(value[0].toString()),
-  );
-};

package/src/lib/erc1271-utils.ts

@@ -1,24 +0,0 @@
-import Web3 from 'web3';
-import type { Contract, ContractSendMethod } from 'web3-eth-contract';
-import { AbiItem } from 'web3-utils';
-import ERC1271ABI from '../abi/ERC1271.abi.json';
-
-export interface ERC1271Contract extends Contract {
-  methods: {
-    isValidSignature(
-      message: string,
-      signature: string,
-    ): Omit<ContractSendMethod, 'call'> & {
-      call: (
-        ...params: Parameters<ContractSendMethod['call']>
-      ) => Promise<boolean>;
-    };
-  };
-}
-
-export const createERC1271Contract = (
-  web3: Web3,
-  addr: string,
-): ERC1271Contract => {
-  return new web3.eth.Contract(ERC1271ABI as AbiItem[], addr);
-};

package/src/lib/fetcher/fetcher.ts

@@ -1,183 +0,0 @@
-import { isFunction } from 'lodash';
-import { Logger } from 'log4js';
-import { IRequestWrapper } from '../../dex-helper';
-import { RequestConfig, Response } from '../../dex-helper/irequest-wrapper';
-
-const FETCH_TIMEOUT_MS = 10 * 1000;
-const FETCH_FAIL_MAX_ATTEMPT = 5;
-const FETCH_FAIL_RETRY_TIMEOUT_MS = 60 * 1000;
-
-export class SkippingRequest {
-  constructor(public message = '') {}
-}
-
-export type RequestInfo<T> = {
-  requestFunc?: (
-    options: RequestConfig,
-  ) => Promise<Response<T> | SkippingRequest>;
-  requestOptions: RequestConfig;
-  caster: (data: unknown) => T;
-  authenticate?: (options: RequestConfig) => RequestConfig;
-  excludedFieldsCaching?: string[];
-};
-
-export type RequestInfoWithHandler<T> = {
-  info: RequestInfo<T>;
-  handler: (data: T) => void;
-};
-
-export class Fetcher<T> {
-  private requests: RequestInfoWithHandler<T>[];
-  public lastFetchSucceeded: boolean = false;
-  private failedCount = 0;
-  private stop: boolean = true;
-
-  constructor(
-    private requestWrapper: IRequestWrapper,
-    requestsInfo: RequestInfoWithHandler<T> | RequestInfoWithHandler<T>[],
-    private pollIntervalMs: number,
-    private logger: Logger,
-  ) {
-    if (Array.isArray(requestsInfo)) {
-      this.requests = requestsInfo;
-    } else {
-      this.requests = [requestsInfo];
-    }
-  }
-
-  async fetch(force: boolean = false) {
-    if (this.stop === true && !force) {
-      return;
-    }
-
-    if (this.failedCount >= FETCH_FAIL_MAX_ATTEMPT) {
-      this.stopPolling();
-
-      setTimeout(() => {
-        this.startPolling();
-        this.failedCount = 0;
-      }, FETCH_FAIL_RETRY_TIMEOUT_MS);
-      return;
-    }
-
-    const promises = this.requests.map<
-      Promise<Error | Response<T> | SkippingRequest>
-    >(async (reqInfo: RequestInfoWithHandler<T>) => {
-      const info = reqInfo.info;
-      let options = info.requestOptions;
-
-      if (info.authenticate) {
-        info.authenticate(options);
-      }
-
-      try {
-        let result;
-        if (isFunction(info.requestFunc)) {
-          result = await info.requestFunc({
-            timeout: FETCH_TIMEOUT_MS,
-            ...options,
-          });
-        } else {
-          result = await this.requestWrapper.request({
-            timeout: FETCH_TIMEOUT_MS,
-            ...options,
-          });
-        }
-
-        return result;
-      } catch (e) {
-        return e as Error;
-      }
-    });
-    const results = await Promise.all(promises);
-    const failures = results
-      .map((_, i) => i)
-      .filter(i => results[i] instanceof Error);
-
-    const skipped = results
-      .map((_, i) => i)
-      .filter(i => results[i] instanceof SkippingRequest);
-
-    results.map(result => {
-      if (!(result instanceof Error || result instanceof SkippingRequest)) {
-        this.logger.info(
-          'Results Data:',
-          JSON.stringify((result as any).data)
-            .replace(/(?:\r\n|\r|\n)/g, ' ')
-            .substring(0, 1000),
-        );
-      }
-    });
-
-    skipped.forEach(i => {
-      const skippedRes = results[i] as SkippingRequest;
-      this.logger.warn(
-        `skipped request ${this.requests[i].info.requestOptions.url} ${skippedRes.message}`,
-      );
-    });
-
-    failures.forEach(i => {
-      this.logger.warn(
-        `failed polling ${this.requests[i].info.requestOptions.url} ${results[i]}`,
-      );
-    });
-
-    if (failures.length === results.length) {
-      this.lastFetchSucceeded = false;
-      this.failedCount += 1;
-    } else {
-      this.lastFetchSucceeded = true;
-    }
-
-    results
-      .map((_, i) => i)
-      .filter(
-        i =>
-          !(
-            results[i] instanceof Error || results[i] instanceof SkippingRequest
-          ),
-      )
-      .forEach(i => {
-        const response = results[i] as Response<T>;
-        const reqInfo = this.requests[i];
-        const info = reqInfo.info;
-        const options = reqInfo.info.requestOptions;
-        this.logger.debug(`(${options.url}) received new data`);
-
-        try {
-          const parsedData = info.caster(response.data);
-          reqInfo.handler(parsedData);
-        } catch (e) {
-          this.logger.info(
-            `(${options.url}) received incorrect data ${JSON.stringify(
-              response.data,
-            ).replace(/(?:\r\n|\r|\n)/g, ' ')}`,
-            e,
-          );
-          return;
-        }
-      });
-    setTimeout(this.fetch.bind(this), this.pollIntervalMs);
-
-    return failures;
-  }
-
-  private getUrls(): string[] {
-    return this.requests.map(el => el.info.requestOptions.url!);
-  }
-
-  startPolling(): void {
-    this.stop = false;
-    this.logger.info(`Polling started for ${this.getUrls()}`);
-    this.fetch();
-  }
-
-  stopPolling() {
-    this.stop = true;
-    this.logger.info(`Polling stopped for ${this.getUrls()}`);
-  }
-
-  isPolling(): boolean {
-    return !this.stop;
-  }
-}

package/src/lib/fetcher/wsFetcher.ts

@@ -1,158 +0,0 @@
-import { Logger } from 'log4js';
-import { RequestConfig, Response } from '../../dex-helper/irequest-wrapper';
-import WebSocket from 'ws';
-export class SkippingRequest {
-  constructor(public message = '') {}
-}
-
-export type RequestInfo<T> = {
-  requestFunc?: (
-    options: RequestConfig,
-  ) => Promise<Response<T> | SkippingRequest>;
-  requestOptions: RequestConfig;
-  caster: (data: unknown) => T;
-  authenticate?: (options: RequestConfig) => RequestConfig;
-  excludedFieldsCaching?: string[];
-};
-
-export type RequestInfoWithHandler<T> = {
-  info: RequestInfo<T>;
-  handler: (data: T) => void;
-};
-
-export class WebSocketFetcher<T> {
-  private requests: RequestInfoWithHandler<T>;
-  // Time to wait before declaring connection as broken and restarting it
-  private timeoutInterval: number;
-  // Time to wait after disconnection before reconnecting
-  private reconnectDelay: number;
-  private pingTimeout: NodeJS.Timeout | undefined = undefined;
-  public lastFetchSucceeded: boolean = false;
-  private stop: boolean = true;
-  private connection: WebSocket | null = null;
-
-  constructor(
-    requestsInfo: RequestInfoWithHandler<T>,
-    private logger: Logger,
-    timeoutInterval: number = 10000,
-    reconnectDelay: number = 5000,
-  ) {
-    this.requests = requestsInfo;
-    this.timeoutInterval = timeoutInterval;
-    this.reconnectDelay = reconnectDelay;
-  }
-
-  private connected() {
-    this.logger.info(`Connected to ${this.requests.info.requestOptions.url}`);
-    this.heartbeat();
-  }
-
-  private heartbeat() {
-    clearTimeout(this.pingTimeout);
-    this.pingTimeout = setTimeout(() => {
-      this.logger.warn('No heartbeat. Terminating Connection...');
-      this?.connection?.terminate();
-    }, this.timeoutInterval);
-  }
-
-  private onClose() {
-    this.logger.info(`Connection closed.`);
-    // Do not reconnect if polling is stopped
-    if (this.stop) {
-      clearTimeout(this.pingTimeout);
-      return;
-    }
-
-    this.logger.info(`Unexpected closure, Reconnecting...`);
-    this.reconnectWithDelay();
-  }
-
-  private onError(error: any) {
-    this.logger.error(
-      `Websocket Error: ${error.toString()}. Stopping & Reconnecting...`,
-    );
-    this?.connection?.terminate();
-  }
-
-  private onMessage(data: WebSocket.RawData) {
-    this.heartbeat();
-    const reqInfo = this.requests;
-    const info = reqInfo.info;
-    const options = reqInfo.info.requestOptions;
-    this.logger.debug(`(${options.url}) received new data`);
-
-    try {
-      const parsedData = info.caster(data);
-      reqInfo.handler(parsedData);
-    } catch (e) {
-      this.logger.info(e);
-      this.logger.info(
-        `(${options.url}) received incorrect data ${JSON.stringify(
-          data,
-        ).replace(/(?:\r\n|\r|\n)/g, ' ')}`,
-        e,
-      );
-      return;
-    }
-  }
-
-  private connect() {
-    const authorization =
-      this.requests.info.requestOptions.headers!.authorization;
-    const name = this.requests.info.requestOptions.headers!.name;
-    if (typeof authorization !== 'string') {
-      throw new Error('Authorization header is not a string');
-    }
-    if (typeof name !== 'string') {
-      throw new Error('Name header is not a string');
-    }
-    this.logger.info(
-      `Connecting to ${this.requests.info.requestOptions.url}...`,
-    );
-    const ws = new WebSocket(this.requests.info.requestOptions.url!, {
-      headers: {
-        Authorization: authorization,
-        name: name,
-      },
-    });
-
-    ws.on('open', this.connected.bind(this));
-    ws.on('message', this.onMessage.bind(this));
-    ws.on('error', this.onError.bind(this));
-    ws.on('close', this.onClose.bind(this));
-    this.connection = ws;
-  }
-
-  reconnectWithDelay() {
-    this.logger.info(`Waiting ${this.reconnectDelay}ms before reconnecting...`);
-    clearTimeout(this.pingTimeout);
-    setTimeout(() => {
-      this.reconnect();
-    }, this.reconnectDelay);
-  }
-
-  reconnect() {
-    clearTimeout(this.pingTimeout);
-    this.connect();
-    this.logger.info(
-      `Connection started for ${this.requests.info.requestOptions.url}`,
-    );
-  }
-
-  startPolling(): void {
-    this.stop = false;
-    this.reconnect();
-  }
-
-  stopPolling() {
-    this.stop = true;
-    this.connection?.terminate();
-    this.logger.info(
-      `Connection stopped for ${this.requests.info.requestOptions.url}`,
-    );
-  }
-
-  isPolling(): boolean {
-    return !this.stop;
-  }
-}