@paraswap/dex-lib 3.9.1 → 3.9.2-bebop.0

package/src/dex/bebop/config.ts

@@ -0,0 +1,37 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const BebopConfig: DexConfigMap<DexParams> = {
+  Bebop: {
+    [Network.MAINNET]: {
+      settlementAddress: '0xbbbbbBB520d69a9775E85b458C58c648259FAD5F',
+      chainName: 'ethereum',
+      middleTokens: [
+        '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+        '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
+        '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
+      ],
+    },
+    [Network.ARBITRUM]: {
+      settlementAddress: '0xbbbbbBB520d69a9775E85b458C58c648259FAD5F',
+      chainName: 'arbitrum',
+      middleTokens: [
+        '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8', // USDC.e
+        '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC
+        '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9', // USDT
+        '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH
+      ],
+    },
+    [Network.BASE]: {
+      settlementAddress: '0xbbbbbBB520d69a9775E85b458C58c648259FAD5F',
+      chainName: 'base',
+      middleTokens: ['0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'],
+    },
+    [Network.OPTIMISM]: {
+      settlementAddress: '0xbbbbbBB520d69a9775E85b458C58c648259FAD5F',
+      chainName: 'optimism',
+      middleTokens: ['0x7F5c764cBc14f9669B88837ca1490cCa17c31607'],
+    },
+  },
+};

package/src/dex/bebop/constants.ts

@@ -0,0 +1,15 @@
+export const BEBOP_INIT_TIMEOUT_MS = 5000;
+export const BEBOP_PRICES_CACHE_TTL = 10;
+export const BEBOP_TOKENS_CACHE_TTL = 60;
+export const BEBOP_TOKENS_POLLING_INTERVAL_MS = 30 * 1000;
+export const BEBOP_API_URL = 'https://api.bebop.xyz';
+export const BEBOP_WS_API_URL = 'wss://api.bebop.xyz';
+export const BEBOP_GAS_COST = 120_000;
+export const BEBOP_AUTH_NAME = 'paraswap';
+export const BEBOP_QUOTE_TIMEOUT_MS = 2000;
+export const BEBOP_ERRORS_CACHE_KEY = 'errors';
+export const BEBOP_RESTRICTED_CACHE_KEY = 'restricted';
+// Restrict for BEBOP_RESTRICT_TTL_S if an error occured >= BEBOP_RESTRICT_COUNT_THRESHOLD times within BEBOP_RESTRICT_CHECK_INTERVAL_S interval
+export const BEBOP_RESTRICT_TTL_S = 10 * 60; // 10 min
+export const BEBOP_RESTRICT_CHECK_INTERVAL_MS = 1000 * 60 * 3; // 3 min
+export const BEBOP_RESTRICT_COUNT_THRESHOLD = 3;

package/src/dex/bebop/rate-fetcher.ts

@@ -0,0 +1,138 @@
+import { ETHER_ADDRESS, Network } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import { Fetcher } from '../../lib/fetcher/fetcher';
+import { validateAndCast } from '../../lib/validators';
+import { Logger, Token } from '../../types';
+import {
+  BebopPricingResponse,
+  BebopRateFetcherConfig,
+  BebopTokensResponse,
+} from './types';
+import { pricesResponseValidator, tokensResponseValidator } from './validators';
+import { WebSocketFetcher } from '../../lib/fetcher/wsFetcher';
+
+export class RateFetcher {
+  private pricesFetcher: WebSocketFetcher<BebopPricingResponse>;
+  private pricesCacheKey: string;
+  private pricesCacheTTL: number;
+
+  private tokensFetcher: Fetcher<BebopTokensResponse>;
+  private tokensAddrCacheKey: string;
+  private tokensCacheKey: string;
+  private tokensCacheTTL: number;
+
+  constructor(
+    private dexHelper: IDexHelper,
+    private dexKey: string,
+    private network: Network,
+    private logger: Logger,
+    config: BebopRateFetcherConfig,
+  ) {
+    this.pricesCacheKey = config.rateConfig.pricesCacheKey;
+    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
+    this.pricesFetcher = new WebSocketFetcher<BebopPricingResponse>(
+      {
+        info: {
+          requestOptions: config.rateConfig.pricesReqParams,
+          caster: (data: unknown) => {
+            return validateAndCast<BebopPricingResponse>(
+              data,
+              pricesResponseValidator,
+            );
+          },
+        },
+        handler: this.handlePricesResponse.bind(this),
+      },
+      logger,
+    );
+
+    this.tokensAddrCacheKey = config.rateConfig.tokensAddrCacheKey;
+    this.tokensCacheKey = config.rateConfig.tokensCacheKey;
+    this.tokensCacheTTL = config.rateConfig.tokensCacheTTLSecs;
+    this.tokensFetcher = new Fetcher<BebopTokensResponse>(
+      dexHelper.httpRequest,
+      {
+        info: {
+          requestOptions: config.rateConfig.tokensReqParams,
+          caster: (data: unknown) => {
+            return validateAndCast<BebopTokensResponse>(
+              data,
+              tokensResponseValidator,
+            );
+          },
+        },
+        handler: this.handleTokensResponse.bind(this),
+      },
+      config.rateConfig.tokensIntervalMs,
+      logger,
+    );
+  }
+
+  start() {
+    this.pricesFetcher.startPolling();
+    this.tokensFetcher.startPolling();
+  }
+
+  stop() {
+    this.pricesFetcher.stopPolling();
+    this.tokensFetcher.stopPolling();
+  }
+
+  private handleTokensResponse(resp: BebopTokensResponse): void {
+    const tokenMap: { [address: string]: Token } = {};
+    const tokenAddrMap: { [symbol: string]: Token } = {};
+
+    Object.keys(resp.tokens).forEach(tokenSymbol => {
+      const token = resp.tokens[tokenSymbol];
+      const tokenData = {
+        address: token.contractAddress.toLowerCase(),
+        symbol: token.ticker,
+        decimals: token.decimals,
+      };
+      tokenAddrMap[token.contractAddress.toLowerCase()] = tokenData;
+      tokenMap[token.ticker.toLowerCase()] = tokenData;
+    });
+
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.tokensCacheKey,
+      this.tokensCacheTTL,
+      JSON.stringify(tokenMap),
+    );
+
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.tokensAddrCacheKey,
+      this.tokensCacheTTL,
+      JSON.stringify(tokenAddrMap),
+    );
+  }
+
+  private handlePricesResponse(resp: BebopPricingResponse): void {
+    const wethAddress =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const normalizedPrices: BebopPricingResponse = {};
+    for (const [pair, levels] of Object.entries(resp)) {
+      normalizedPrices[pair.toLowerCase()] = levels;
+      const [base, quote] = pair.split('/');
+      // Also enter native token prices. Pricing doesn't come with these
+      if (
+        base.toLowerCase() === wethAddress ||
+        quote.toLowerCase() === wethAddress
+      ) {
+        const nativePair = pair.replace(base, ETHER_ADDRESS);
+        normalizedPrices[nativePair.toLowerCase()] = levels;
+      }
+    }
+
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.pricesCacheKey,
+      this.pricesCacheTTL,
+      JSON.stringify(normalizedPrices),
+    );
+  }
+}

package/src/dex/bebop/types.ts

@@ -0,0 +1,90 @@
+import { SwapSide } from '../../constants';
+import { RequestHeaders } from '../../dex-helper';
+
+export type BebopRateFetcherConfig = {
+  rateConfig: {
+    pricesReqParams: {
+      url: string;
+      headers?: RequestHeaders;
+      params?: any;
+    };
+    tokensReqParams: {
+      url: string;
+      headers?: RequestHeaders;
+      params?: any;
+    };
+    tokensIntervalMs: number;
+    pricesCacheKey: string;
+    tokensAddrCacheKey: string;
+    tokensCacheKey: string;
+    pricesCacheTTLSecs: number;
+    tokensCacheTTLSecs: number;
+  };
+};
+
+export type TokenDataMap = { [index: string]: BebopToken };
+
+export type BebopToken = {
+  decimals: number;
+  contractAddress: string;
+  ticker: string;
+};
+
+export type BebopTokensResponse = {
+  tokens: { [symbol: string]: BebopToken };
+};
+
+export type BebopLevel = [price: number, size: number];
+
+export type BebopPair = {
+  bids: BebopLevel[];
+  asks: BebopLevel[];
+  last_update_ts: number;
+};
+
+export type BebopPricingResponse = {
+  [pair: string]: BebopPair;
+};
+
+export interface BebopTx {
+  to: string;
+  value: string;
+  data: string;
+  from: string;
+  gas: number;
+}
+
+export type BebopTokenAmount = {
+  amount: string;
+  priceUsd: number;
+};
+
+// For now nothing but we may have to add something
+export type BebopData = {
+  expiry?: number;
+  buyTokens?: { [address: string]: BebopTokenAmount };
+  sellTokens?: { [address: string]: BebopTokenAmount };
+  tx?: BebopTx;
+};
+
+export type DexParams = {
+  settlementAddress: string;
+  chainName: string;
+  middleTokens: string[];
+};
+
+export type RoutingInstruction = {
+  side: SwapSide; // Buy for bids, Sell for asks
+  book: BebopPair;
+  pair: string;
+  targetQuote: boolean;
+};
+
+export class SlippageError extends Error {
+  isSlippageError = true;
+}
+
+export type RestrictData = {
+  count: number;
+  addedDatetimeMs: number;
+} | null;

package/src/dex/bebop/validators.ts

@@ -0,0 +1,29 @@
+import joi from 'joi';
+
+const levelValidator = joi.array().items(joi.number()).length(2);
+
+const pairValidator = joi.object({
+  bids: joi.array().items(levelValidator).required(),
+  asks: joi.array().items(levelValidator).required(),
+  last_update_ts: joi.number().min(0).required(),
+});
+
+export const pricesResponseValidator = joi
+  .object()
+  .pattern(joi.string(), pairValidator);
+
+const tokenValidator = joi
+  .object({
+    ticker: joi.string().min(1).required(),
+    contractAddress: joi.string().min(1).required(),
+    decimals: joi.number().min(0).required(),
+  })
+  .unknown(true);
+
+export const tokensResponseValidator = joi.object({
+  tokens: joi.object().pattern(joi.string(), tokenValidator),
+});
+
+export const blacklistResponseValidator = joi.object({
+  blacklist: joi.array().items(joi.string().min(1)).required(),
+});

package/src/dex/index.ts

@@ -77,6 +77,7 @@ import { AngleStakedStable } from './angle-staked-stable/angle-staked-stable';
 import { QuickPerps } from './quick-perps/quick-perps';
 import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 import { Dexalot } from './dexalot/dexalot';
+import { Bebop } from './bebop/bebop';
 import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
 import { PharaohV1 } from './solidly/forks-override/pharaohV1';
@@ -111,6 +112,7 @@ const LegacyDexes = [
 ];
 
 const Dexes = [
+  Bebop,
   Dexalot,
   CurveV1,
   CurveFork,

package/src/executor/Executor01BytecodeBuilder.ts

@@ -80,8 +80,9 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
       Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
 
     if (isEthSrc && !needWrap) {
-      dexFlag =
-        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
+      dexFlag = dexFuncHasRecipient
+        ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+        : Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
     } else if (isEthDest && !needUnwrap) {
       dexFlag = forcePreventInsertFromAmount
         ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP

package/src/executor/Executor02BytecodeBuilder.ts

@@ -107,8 +107,9 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
       Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
 
     if (isEthSrc && !needWrap) {
-      dexFlag =
-        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
+      dexFlag = dexFuncHasRecipient
+        ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+        : Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
     } else if (isEthDest && !needUnwrap) {
       dexFlag = forcePreventInsertFromAmount
         ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP

package/src/executor/Executor03BytecodeBuilder.ts

@@ -93,8 +93,9 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
 
     if (isEthSrc && !needWrap) {
-      dexFlag =
-        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
+      dexFlag = dexFuncHasRecipient
+        ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+        : Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
     } else if (isEthDest && !needUnwrap) {
       dexFlag = forcePreventInsertFromAmount
         ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 4

package/src/lib/fetcher/wsFetcher.ts

@@ -0,0 +1,145 @@
+import { Logger } from 'log4js';
+import { RequestConfig, Response } from '../../dex-helper/irequest-wrapper';
+import {
+  connection as WebSocketConnection,
+  client as WebSocketClient,
+} from 'websocket';
+
+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>;
+  public lastFetchSucceeded: boolean = false;
+  private stop: boolean = true;
+  private ws: WebSocketClient = new WebSocketClient();
+  private connection: WebSocketConnection | null = null;
+
+  constructor(requestsInfo: RequestInfoWithHandler<T>, private logger: Logger) {
+    this.requests = requestsInfo;
+    this.ws.on('connect', this.connected.bind(this));
+    this.ws.on('connectFailed', this.connectFailed.bind(this));
+  }
+
+  private connected(connection: WebSocketConnection) {
+    this.connection = connection;
+    this.logger.info(`Connected to ${this.requests.info.requestOptions.url}`);
+    this.connection.on('error', this.onError.bind(this));
+    this.connection.on('close', this.onClose.bind(this));
+    this.connection.on('message', this.onMessage.bind(this));
+  }
+
+  private connectFailed(error: any) {
+    this.logger.error(`Connect Error: ${error.toString()}. Reconnecting...`);
+    // reconnect on errors / failures
+    setTimeout(() => {
+      this.startPolling();
+    }, 3000);
+  }
+
+  private onClose() {
+    this.logger.info(`Connection closed. Reconnecting...`);
+    // reconnect on errors / failures
+    setTimeout(() => {
+      this.startPolling();
+    }, 3000);
+  }
+
+  private onError(error: any) {
+    this.logger.error(
+      `Connection Error: ${error.toString()}. Stopping & Reconnecting...`,
+    );
+    this.stopPolling();
+
+    // reconnect on errors / failures
+    setTimeout(() => {
+      this.startPolling();
+    }, 3000);
+  }
+
+  private onMessage(message: any) {
+    if (message.type === 'utf8') {
+      const response = JSON.parse(message.utf8Data) as Response<T>;
+      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(response);
+        reqInfo.handler(parsedData);
+      } catch (e) {
+        this.logger.info(e);
+        this.logger.info(
+          `(${options.url}) received incorrect data ${JSON.stringify(
+            response,
+          ).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}...`,
+    );
+    this.ws.connect(
+      this.requests.info.requestOptions.url!,
+      undefined,
+      undefined,
+      {
+        Authorization: authorization,
+        name: name,
+      },
+    );
+  }
+
+  startPolling(): void {
+    this.stop = false;
+    this.connect();
+    this.logger.info(
+      `Connection started for ${this.requests.info.requestOptions.url}`,
+    );
+  }
+
+  stopPolling() {
+    if (this.connection) {
+      this.connection.close();
+    }
+    this.stop = true;
+    this.logger.info(
+      `Connection stopped for ${this.requests.info.requestOptions.url}`,
+    );
+  }
+
+  isPolling(): boolean {
+    return !this.stop;
+  }
+}

package/src/types.ts

@@ -310,6 +310,7 @@ export type Config = {
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
   dexalotAuthToken?: string;
+  bebopAuthToken?: string;
   idleDaoAuthToken?: string;
   forceRpcFallbackDexs: string[];
   apiKeyTheGraph: string;