@paraswap/dex-lib 4.1.20 → 4.1.21

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -1,491 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { isEmpty, omit } from 'lodash';
-import { SwapSide } from '@paraswap/core';
-import { BN_1 } from '../../bignumber-constants';
-import { IDexHelper } from '../../dex-helper';
-import { RequestConfig } from '../../dex-helper/irequest-wrapper';
-import { Fetcher } from '../../lib/fetcher/fetcher';
-
-import { Logger, Address, Token } from '../../types';
-import { OrderInfo } from '../paraswap-limit-orders/types';
-import {
-  BlackListResponse,
-  PairMap,
-  PairsResponse,
-  PriceAndAmount,
-  PriceAndAmountBigNumber,
-  RatesResponse,
-  RFQConfig,
-  RFQFirmRateResponse,
-  RFQPayload,
-  RFQSecret,
-  TokensResponse,
-  TokenWithInfo,
-} from './types';
-import { checkOrder } from './utils';
-import {
-  blacklistResponseValidator,
-  firmRateWithTakerValidator,
-  pairsResponseValidator,
-  pricesResponse,
-  tokensResponseValidator,
-} from './validators';
-import { genericRFQAuthHttp } from './security';
-import { validateAndCast } from '../../lib/validators';
-import {
-  createERC1271Contract,
-  ERC1271Contract,
-} from '../../lib/erc1271-utils';
-import { isContractAddress } from '../../utils';
-
-const GET_FIRM_RATE_TIMEOUT_MS = 2000;
-export const reversePrice = (price: PriceAndAmountBigNumber) =>
-  [
-    BN_1.dividedBy(price[0]),
-    price[1].times(price[0]),
-  ] as PriceAndAmountBigNumber;
-
-export class RateFetcher {
-  private tokensFetcher: Fetcher<TokensResponse>;
-  private pairsFetcher: Fetcher<PairsResponse>;
-  private rateFetcher: Fetcher<RatesResponse>;
-  private blackListFetcher?: Fetcher<BlackListResponse>;
-
-  private tokens: Record<string, TokenWithInfo> = {};
-  private addressToTokenMap: Record<string, TokenWithInfo> = {};
-  private pairs: PairMap = {};
-
-  private firmRateAuth?: (options: RequestConfig) => void;
-
-  public blackListCacheKey: string;
-
-  private authHttp: (
-    secret: RFQSecret,
-  ) => (options: RequestConfig) => RequestConfig;
-
-  private verifierContract?: ERC1271Contract;
-
-  constructor(
-    private dexHelper: IDexHelper,
-    private config: RFQConfig,
-    private dexKey: string,
-    private logger: Logger,
-  ) {
-    this.authHttp = genericRFQAuthHttp(config.pathToRemove);
-    this.tokensFetcher = new Fetcher<TokensResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.tokensConfig.reqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<TokensResponse>(
-              data,
-              tokensResponseValidator,
-            );
-          },
-          authenticate: this.authHttp(config.tokensConfig.secret),
-        },
-        handler: this.handleTokensResponse.bind(this),
-      },
-      config.tokensConfig.intervalMs,
-      this.logger,
-    );
-
-    this.pairsFetcher = new Fetcher<PairsResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.pairsConfig.reqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<PairsResponse>(data, pairsResponseValidator);
-          },
-          authenticate: this.authHttp(config.pairsConfig.secret),
-        },
-        handler: this.handlePairsResponse.bind(this),
-      },
-      config.pairsConfig.intervalMs,
-      this.logger,
-    );
-
-    this.rateFetcher = new Fetcher<RatesResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.reqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<RatesResponse>(data, pricesResponse);
-          },
-          authenticate: this.authHttp(config.rateConfig.secret),
-        },
-        handler: this.handleRatesResponse.bind(this),
-      },
-      config.rateConfig.intervalMs,
-      logger,
-    );
-
-    if (config.blacklistConfig) {
-      this.blackListFetcher = new Fetcher<BlackListResponse>(
-        dexHelper.httpRequest,
-        {
-          info: {
-            requestOptions: config.blacklistConfig.reqParams,
-            caster: (data: unknown) => {
-              return validateAndCast<BlackListResponse>(
-                data,
-                blacklistResponseValidator,
-              );
-            },
-            authenticate: this.authHttp(config.rateConfig.secret),
-          },
-          handler: this.handleBlackListResponse.bind(this),
-        },
-        config.blacklistConfig.intervalMs,
-        logger,
-      );
-    }
-
-    this.blackListCacheKey = `${this.dexHelper.config.data.network}_${this.dexKey}_blacklist`;
-    if (this.config.firmRateConfig.secret) {
-      this.firmRateAuth = this.authHttp(this.config.firmRateConfig.secret);
-    }
-  }
-
-  async initialize() {
-    const isContract = await isContractAddress(
-      this.dexHelper.web3Provider,
-      this.config.maker,
-    );
-    if (isContract) {
-      this.verifierContract = createERC1271Contract(
-        this.dexHelper.web3Provider,
-        this.config.maker,
-      );
-    }
-  }
-
-  start() {
-    this.tokensFetcher.startPolling();
-    this.rateFetcher.startPolling();
-    this.pairsFetcher.startPolling();
-    if (this.blackListFetcher) {
-      this.blackListFetcher.startPolling();
-    }
-  }
-
-  stop() {
-    this.tokensFetcher.stopPolling();
-    this.pairsFetcher.stopPolling();
-    this.rateFetcher.stopPolling();
-
-    if (this.blackListFetcher) {
-      this.blackListFetcher.stopPolling();
-    }
-  }
-
-  private handleTokensResponse(data: TokensResponse) {
-    for (const tokenName of Object.keys(data.tokens)) {
-      const token = data.tokens[tokenName];
-      token.address = token.address.toLowerCase();
-      this.tokens[tokenName] = token;
-    }
-
-    this.addressToTokenMap = Object.keys(this.tokens).reduce((acc, key) => {
-      const obj = this.tokens[key];
-      if (!obj) {
-        return acc;
-      }
-      acc[obj.address.toLowerCase()] = obj;
-      return acc;
-    }, {} as Record<string, TokenWithInfo>);
-  }
-
-  private handlePairsResponse(resp: PairsResponse) {
-    this.pairs = {};
-
-    const pairs: PairMap = {};
-    for (const pairName of Object.keys(resp.pairs)) {
-      pairs[pairName] = resp.pairs[pairName];
-    }
-
-    this.pairs = pairs;
-  }
-
-  private handleBlackListResponse(resp: BlackListResponse) {
-    for (const address of resp.blacklist) {
-      this.dexHelper.cache.sadd(this.blackListCacheKey, address.toLowerCase());
-    }
-  }
-
-  public isBlackListed(userAddress: string) {
-    return this.dexHelper.cache.sismember(
-      this.blackListCacheKey,
-      userAddress.toLowerCase(),
-    );
-  }
-
-  private handleRatesResponse(resp: RatesResponse) {
-    const pairs = this.pairs;
-
-    if (isEmpty(pairs)) return;
-
-    const currentPricePairs = new Set();
-
-    Object.keys(resp.prices).forEach(pairName => {
-      const pair = pairs[pairName];
-      if (!pair) {
-        return;
-      }
-      const prices = resp.prices[pairName];
-
-      if (!prices.asks || !prices.bids) {
-        return;
-      }
-
-      if (isEmpty(this.tokens)) return;
-
-      const baseToken = this.tokens[pair.base];
-      const quoteToken = this.tokens[pair.quote];
-
-      if (!baseToken || !quoteToken) {
-        this.logger.warn(`missing base or quote token`);
-        return;
-      }
-
-      if (prices.bids.length) {
-        this.dexHelper.cache.setex(
-          this.dexKey,
-          this.dexHelper.config.data.network,
-          `${baseToken.address}_${quoteToken.address}_bids`,
-          this.config.rateConfig.dataTTLS,
-          JSON.stringify(prices.bids),
-        );
-        currentPricePairs.add(`${baseToken.address}_${quoteToken.address}`);
-      }
-
-      if (prices.asks.length) {
-        this.dexHelper.cache.setex(
-          this.dexKey,
-          this.dexHelper.config.data.network,
-          `${baseToken.address}_${quoteToken.address}_asks`,
-          this.config.rateConfig.dataTTLS,
-          JSON.stringify(prices.asks),
-        );
-        currentPricePairs.add(`${quoteToken.address}_${baseToken.address}`);
-      }
-    });
-
-    if (currentPricePairs.size > 0) {
-      this.dexHelper.cache.setex(
-        this.dexKey,
-        this.dexHelper.config.data.network,
-        `pairs`,
-        this.config.rateConfig.dataTTLS,
-        JSON.stringify(Array.from(currentPricePairs)),
-      );
-    }
-  }
-
-  checkHealth(): boolean {
-    return [this.tokensFetcher, this.rateFetcher].some(
-      f => f.lastFetchSucceeded,
-    );
-  }
-
-  public getPairsLiquidity(tokenAddress: string) {
-    const token = this.addressToTokenMap[tokenAddress];
-
-    const pairNames = Object.keys(this.pairs);
-    const pairs = Object.values(this.pairs);
-
-    return pairs
-      .filter((p, index) => pairNames[index].includes(token.symbol!))
-      .map(p => {
-        const baseToken = this.tokens[p.base];
-        const quoteToken = this.tokens[p.quote];
-        let connectorToken: Token | undefined;
-        if (baseToken.address !== tokenAddress) {
-          connectorToken = {
-            address: baseToken.address,
-            decimals: baseToken.decimals,
-          };
-        } else {
-          connectorToken = {
-            address: quoteToken.address,
-            decimals: quoteToken.decimals,
-          };
-        }
-        return {
-          connectorTokens: [connectorToken],
-          liquidityUSD: p.liquidityUSD,
-        };
-      });
-  }
-
-  public async getAvailablePairs(): Promise<string[]> {
-    const pairs = await this.dexHelper.cache.getAndCacheLocally(
-      this.dexKey,
-      this.dexHelper.config.data.network,
-      `pairs`,
-      this.config.rateConfig.intervalMs / 1000,
-    );
-
-    if (!pairs) {
-      return [];
-    }
-
-    return JSON.parse(pairs) as string[];
-  }
-
-  public async getOrderPrice(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-  ): Promise<PriceAndAmountBigNumber[] | null> {
-    let reversed = false;
-
-    let pricesAsString: string | null = null;
-    if (side === SwapSide.SELL) {
-      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-        this.dexKey,
-        this.dexHelper.config.data.network,
-        `${srcToken.address}_${destToken.address}_bids`,
-        this.config.rateConfig.intervalMs / 1000,
-      );
-
-      if (!pricesAsString) {
-        pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-          this.dexKey,
-          this.dexHelper.config.data.network,
-          `${destToken.address}_${srcToken.address}_asks`,
-          this.config.rateConfig.intervalMs / 1000,
-        );
-        reversed = true;
-      }
-    } else {
-      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-        this.dexKey,
-        this.dexHelper.config.data.network,
-        `${destToken.address}_${srcToken.address}_asks`,
-        this.config.rateConfig.intervalMs / 1000,
-      );
-
-      if (!pricesAsString) {
-        pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-          this.dexKey,
-          this.dexHelper.config.data.network,
-          `${srcToken.address}_${destToken.address}_bids`,
-          this.config.rateConfig.intervalMs / 1000,
-        );
-        reversed = true;
-      }
-    }
-
-    if (!pricesAsString) {
-      return null;
-    }
-
-    const orderPricesAsString: PriceAndAmount[] = JSON.parse(pricesAsString);
-    if (!orderPricesAsString) {
-      return null;
-    }
-
-    let orderPrices = orderPricesAsString.map(price => [
-      new BigNumber(price[0]),
-      new BigNumber(price[1]),
-    ]);
-
-    if (reversed) {
-      orderPrices = orderPrices.map(price =>
-        reversePrice(price as PriceAndAmountBigNumber),
-      );
-    }
-
-    return orderPrices as PriceAndAmountBigNumber[];
-  }
-
-  async getFirmRate(
-    _srcToken: Token,
-    _destToken: Token,
-    srcAmount: string,
-    side: SwapSide,
-    takerAddress: Address,
-    userAddress: Address,
-    partner?: string,
-    special?: boolean,
-  ): Promise<OrderInfo> {
-    const srcToken = this.dexHelper.config.wrapETH(_srcToken);
-    const destToken = this.dexHelper.config.wrapETH(_destToken);
-
-    if (BigInt(srcAmount) === 0n) {
-      throw new Error('getFirmRate failed with srcAmount == 0');
-    }
-
-    const _payload: RFQPayload = {
-      makerAsset: destToken.address,
-      takerAsset: srcToken.address,
-      makerAmount: side === SwapSide.BUY ? srcAmount : undefined,
-      takerAmount: side === SwapSide.SELL ? srcAmount : undefined,
-      userAddress,
-      takerAddress,
-      partner,
-      special: special || false,
-    };
-
-    try {
-      let payload = {
-        data: _payload,
-        ...this.config.firmRateConfig,
-        timeout: GET_FIRM_RATE_TIMEOUT_MS,
-      };
-
-      this.logger.info(
-        'FirmRate Request:',
-        JSON.stringify(omit(payload, 'secret')).replace(/(?:\r\n|\r|\n)/g, ' '),
-      );
-
-      if (this.firmRateAuth) {
-        this.firmRateAuth(payload);
-        delete payload.secret;
-      }
-      const { data } = await this.dexHelper.httpRequest.request<unknown>(
-        payload,
-      );
-      this.logger.info(
-        'FirmRate Response: ',
-        JSON.stringify(data).replace(/(?:\r\n|\r|\n)/g, ' '),
-      );
-      const firmRateResp = validateAndCast<RFQFirmRateResponse>(
-        data,
-        firmRateWithTakerValidator(takerAddress),
-      );
-
-      await checkOrder(
-        this.dexHelper.config.data.network,
-        this.dexHelper.config.data.augustusRFQAddress,
-        this.dexHelper.multiWrapper,
-        firmRateResp.order,
-        this.verifierContract,
-      );
-
-      return {
-        order: {
-          maker: firmRateResp.order.maker,
-          taker: firmRateResp.order.taker,
-          expiry: firmRateResp.order.expiry,
-          nonceAndMeta: firmRateResp.order.nonceAndMeta,
-          makerAsset: firmRateResp.order.makerAsset,
-          takerAsset: firmRateResp.order.takerAsset,
-          makerAmount: firmRateResp.order.makerAmount,
-          takerAmount: firmRateResp.order.takerAmount,
-        },
-        signature: firmRateResp.order.signature,
-        takerTokenFillAmount: firmRateResp.order.takerAmount,
-        permitMakerAsset: '0x',
-        permitTakerAsset: '0x',
-      };
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-  }
-}

package/src/dex/generic-rfq/security.ts

@@ -1,55 +0,0 @@
-import {
-  RequestConfig,
-  RequestHeaders,
-} from '../../dex-helper/irequest-wrapper';
-import { createHmac } from 'crypto';
-import { RFQSecret } from './types';
-
-function authByParams(
-  url: string,
-  method: string,
-  body: any,
-  secret: RFQSecret,
-  pathToRemove?: string,
-): RequestHeaders {
-  const headers: RequestHeaders = {};
-  const timestamp = Date.now().toString();
-
-  const _url = new URL(url);
-  if (pathToRemove && pathToRemove !== '') {
-    _url.pathname = _url.pathname.replace(`/${pathToRemove}`, '');
-  }
-  const payload = `${timestamp}${method.toUpperCase()}${_url.pathname}${
-    _url.search
-  }${method === 'POST' ? JSON.stringify(body) : ''}`;
-  const signature = createHmac('sha256', secret.secretKey);
-  signature.update(payload);
-
-  headers['X-AUTH-TIMESTAMP'] = timestamp;
-  headers['X-AUTH-SIGNATURE'] = signature.digest('hex');
-
-  return headers;
-}
-
-export const genericRFQAuthHttp =
-  (pathToRemove?: string) =>
-  (secret: RFQSecret) =>
-  (options: RequestConfig): RequestConfig => {
-    let { data: body, method, url } = options;
-    if (!options.headers) {
-      options.headers = {};
-    }
-    method = method || 'GET';
-    if (!url) {
-      throw new Error('missing url');
-    }
-
-    const headers = authByParams(url, method, body, secret, pathToRemove);
-    for (const [header, value] of Object.entries(headers)) {
-      options.headers[header] = value;
-    }
-
-    options.headers['X-AUTH-DOMAIN'] = secret.domain;
-    options.headers['X-AUTH-ACCESS-KEY'] = secret.accessKey;
-    return options;
-  };

package/src/dex/generic-rfq/types.ts

@@ -1,120 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { RequestConfig } from '../../dex-helper/irequest-wrapper';
-import { Address, NumberAsString, Token } from '../../types';
-import {
-  AugustusOrderWithString,
-  OrderInfo,
-} from '../paraswap-limit-orders/types';
-
-export type Pair = {
-  base: string;
-  quote: string;
-  liquidityUSD: number;
-};
-
-export type PairMap = {
-  [pairName: string]: Pair;
-};
-
-export type PairsResponse = {
-  pairs: PairMap;
-};
-
-export type TokenWithInfo = Token & {
-  name: string;
-  description: string;
-};
-
-export type TokensResponse = {
-  tokens: Record<string, TokenWithInfo>;
-};
-
-export type BlackListResponse = {
-  blacklist: string[];
-};
-
-export type PriceAndAmount = [string, string];
-
-export type PriceAndAmountBigNumber = [BigNumber, BigNumber];
-
-export type PairPriceResponse = {
-  bids?: PriceAndAmount[];
-  asks?: PriceAndAmount[];
-};
-
-export type RatesResponse = {
-  prices: { [pair: string]: PairPriceResponse };
-};
-
-export type RFQSecret = {
-  domain: string;
-  accessKey: string;
-  secretKey: string;
-};
-
-export type FetcherParams = {
-  reqParams: RequestConfig;
-  secret: RFQSecret;
-  intervalMs: number;
-  dataTTLS: number;
-};
-
-export type Rates = Array<[string, string]>;
-export type BigNumberRate = [BigNumber, BigNumber];
-export type BigNumberRates = Array<BigNumberRate>;
-
-type RequestConfigWithAuth = RequestConfig & {
-  secret?: RFQSecret;
-};
-
-export type RFQConfig = {
-  tokensConfig: FetcherParams;
-  pairsConfig: FetcherParams;
-  rateConfig: FetcherParams;
-  firmRateConfig: RequestConfigWithAuth;
-  blacklistConfig?: FetcherParams;
-  maker: Address;
-  pathToRemove?: string;
-};
-
-export type TokenWithAmount = Token & {
-  amount: string;
-};
-
-export type RFQPayload = {
-  makerAsset: Address;
-  takerAsset: Address;
-  makerAmount?: string;
-  takerAmount?: string;
-  userAddress: Address;
-  takerAddress: Address;
-  partner?: string;
-  special?: boolean;
-};
-
-export type AugustusOrderWithStringAndSignature = AugustusOrderWithString & {
-  signature: string;
-};
-
-export type RFQFirmRateResponse = {
-  status: 'accepted' | 'rejected';
-  order: AugustusOrderWithStringAndSignature;
-};
-
-export class SlippageCheckError extends Error {}
-
-export class TooStrictSlippageCheckError extends Error {}
-
-export type RFQParams = [
-  fromAmount: NumberAsString,
-  toAmount: NumberAsString,
-  wrapApproveDirection: NumberAsString,
-  metadata: string,
-  beneficiary: Address,
-];
-
-export type RFQDirectPayload = [
-  params: RFQParams,
-  orders: OrderInfo[],
-  permit: string,
-];