@paraswap/dex-lib 3.8.37 → 3.8.39-bebop

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,9 @@
+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;

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,81 @@
+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;
+};

package/src/dex/bebop/validators.ts

@@ -0,0 +1,43 @@
+import joi from 'joi';
+
+// const pairValidator = joi.object({
+//   base: joi.string().min(1).required(),
+//   quote: joi.string().min(1).required(),
+//   liquidityUSD: joi.number().min(0).required(),
+//   baseAddress: joi.string().min(1).required(),
+//   quoteAddress: joi.string().min(1).required(),
+//   baseDecimals: joi.number().min(0).required(),
+//   quoteDecimals: joi.number().min(0).required(),
+// });
+
+// export const pairsResponseValidator = joi
+//   .object()
+//   .pattern(joi.string(), pairValidator);
+
+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

@@ -76,6 +76,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';
@@ -110,6 +111,7 @@ const LegacyDexes = [
 ];
 
 const Dexes = [
+  Bebop,
   Dexalot,
   CurveV1,
   CurveFork,

package/src/dex/spark/config.ts

@@ -2,6 +2,9 @@ import { SparkParams } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
 import { SwapSide } from '@paraswap/core';
+import PotAbi from '../../abi/maker-psm/pot.json';
+import SavingsUSDSAbi from '../../abi/sdai/SavingsUSDS.abi.json';
+import { Interface } from '@ethersproject/abi';
 
 export const SDaiConfig: DexConfigMap<SparkParams> = {
   Spark: {
@@ -9,6 +12,27 @@ export const SDaiConfig: DexConfigMap<SparkParams> = {
       sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
       daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
       potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+      savingsRate: {
+        symbol: 'dsr',
+        // bytes32 repr of "dsr" string
+        topic:
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(PotAbi),
+    },
+  },
+  sUSDS: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // sUSDS
+      daiAddress: '0xdC035D45d973E3EC169d2276DDab16f1e407384F', // USDS
+      potAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // no separate pot, sUSDS is the pot
+      savingsRate: {
+        symbol: 'ssr',
+        // bytes32 repr of "ssr" string
+        topic:
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(SavingsUSDSAbi),
     },
   },
 };

package/src/dex/spark/scripts/validate-state.ts

@@ -72,6 +72,7 @@ async function isPoolStateEqualToReal(
     dexHelper.multiContract,
     potAddress,
     new Interface(PotAbi),
+    'dsr',
     blockNumber,
   );
 

package/src/dex/spark/spark-e2e.test.ts

@@ -23,23 +23,8 @@ function testForNetwork(
   const holders = Holders[network];
 
   const sideToContractMethods = new Map([
-    [
-      SwapSide.SELL,
-      [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
-        ContractMethod.swapExactAmountIn,
-      ],
-    ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-        ContractMethod.swapExactAmountOut,
-      ],
-    ],
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -80,10 +65,9 @@ function testForNetwork(
   });
 }
 
-describe('sDAI E2E', () => {
-  const dexKey = 'Spark';
-
-  describe('Mainnet', () => {
+describe('Spark E2E', () => {
+  describe('sDai', () => {
+    const dexKey = 'Spark';
     const network = Network.MAINNET;
 
     const tokenASymbol: string = 'DAI';
@@ -101,4 +85,24 @@ describe('sDAI E2E', () => {
       tokenBAmount,
     );
   });
+
+  describe('sUSDS', () => {
+    const dexKey = 'sUSDS';
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USDS';
+    const tokenBSymbol: string = 'sUSDS';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
 });

package/src/dex/spark/spark-events.test.ts

@@ -12,41 +12,7 @@ import PotAbi from '../../abi/maker-psm/pot.json';
 import { Interface } from '@ethersproject/abi';
 import _ from 'lodash';
 
-/*
-  README
-  ======
-
-  This test script adds unit tests for SDai event based
-  system. This is done by fetching the state on-chain before the
-  event block, manually pushing the block logs to the event-subscriber,
-  comparing the local state with on-chain state.
-
-  Most of the logic for testing is abstracted by `testEventSubscriber`.
-  You need to do two things to make the tests work:
-
-  1. Fetch the block numbers where certain events were released. You
-  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
-  block numbers for different events. Make sure to get sufficient
-  number of blockNumbers to cover all possible cases for the event
-  mutations.
-
-  2. Complete the implementation for fetchPoolState function. The
-  function should fetch the on-chain state of the event subscriber
-  using just the blocknumber.
-
-  The template tests only include the test for a single event
-  subscriber. There can be cases where multiple event subscribers
-  exist for a single DEX. In such cases additional tests should be
-  added.
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
-
-  (This comment should be removed from the final implementation)
-*/
-
 jest.setTimeout(50 * 1000);
-const dexKey = 'Spark';
 const network = Network.MAINNET;
 
 async function fetchPoolState(
@@ -56,7 +22,8 @@ async function fetchPoolState(
   return sdaiPool.generateState(blockNumber);
 }
 
-describe('SDai Event', function () {
+describe('SDai', function () {
+  const dexKey = 'Spark';
   const blockNumbers: { [eventName: string]: number[] } = {
     drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
     // TODO: no matching logs, you have to manually call "file"
@@ -69,33 +36,81 @@ describe('SDai Event', function () {
     potAddress: SDaiConfig[dexKey][network].potAddress,
   };
 
-  describe('SDaiPool', function () {
-    Object.keys(blockNumbers).forEach((event: string) => {
-      blockNumbers[event].forEach((blockNumber: number) => {
-        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
-          const dexHelper = new DummyDexHelper(network);
-          const logger = dexHelper.getLogger(dexKey);
-
-          const sdaiPool = new SparkSDaiEventPool(
-            dexKey,
-            `dai-sdai-pool`,
-            dexHelper,
-            addresses.potAddress,
-            new Interface(PotAbi),
-            logger,
-          );
-
-          await sdaiPool.initialize(blockNumber);
-
-          await testEventSubscriber(
-            sdaiPool,
-            sdaiPool.addressesSubscribed,
-            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
-            blockNumber,
-            `${dexKey}_${sdaiPool}`,
-            dexHelper.provider,
-          );
-        });
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  Object.keys(blockNumbers).forEach((event: string) => {
+    blockNumbers[event].forEach((blockNumber: number) => {
+      it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+        const dexHelper = new DummyDexHelper(network);
+        const logger = dexHelper.getLogger(dexKey);
+
+        const sdaiPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `dai-sdai-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+          'dsr',
+        );
+
+        await sdaiPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sdaiPool,
+          sdaiPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sdaiPool}`,
+          dexHelper.provider,
+        );
+      });
+    });
+  });
+});
+
+describe('sUSDS', function () {
+  const dexKey = 'sUSDS';
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [20812786, 20812797, 20813343, 20813668, 20814065, 20814418],
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  Object.keys(blockNumbers).forEach((event: string) => {
+    blockNumbers[event].forEach((blockNumber: number) => {
+      it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+        const dexHelper = new DummyDexHelper(network);
+        const logger = dexHelper.getLogger(dexKey);
+
+        const sUSDSPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `usds-susds-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+          'ssr',
+        );
+
+        await sUSDSPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sUSDSPool,
+          sUSDSPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sUSDSPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sUSDSPool}`,
+          dexHelper.provider,
+        );
       });
     });
   });