@paraswap/dex-lib 2.50.5 → 2.50.6-sdai

package/src/dex/hashflow/hashflow.ts

@@ -33,14 +33,11 @@ import {
   SimpleExchangeParam,
   Token,
 } from '../../types';
-import { getDexKeysWithNetwork, Utils } from '../../utils';
+import { getDexKeysWithNetwork } from '../../utils';
 import { TooStrictSlippageCheckError } from '../generic-rfq/types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, HashflowConfig } from './config';
 import {
-  CONSECUTIVE_ERROR_THRESHOLD,
-  CONSECUTIVE_ERROR_TIMESPAN_MS,
-  ERROR_CODE_TO_RESTRICT_TTL,
   HASHFLOW_API_CLIENT_NAME,
   HASHFLOW_API_MARKET_MAKERS_POLLING_INTERVAL_MS,
   HASHFLOW_API_PRICES_POLLING_INTERVAL_MS,
@@ -51,12 +48,9 @@ import {
   HASHFLOW_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION,
   HASHFLOW_MM_RESTRICT_TTL_S,
   HASHFLOW_PRICES_CACHES_TTL_S,
-  UNKNOWN_ERROR_CODE,
 } from './constants';
 import { RateFetcher } from './rate-fetcher';
 import {
-  CacheErrorCodesData,
-  ErrorCode,
   HashflowData,
   PriceLevel,
   RfqError,
@@ -75,7 +69,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   private hashFlowAuthToken: string;
   private disabledMMs: Set<string>;
   private runtimeMMsRestrictHashMapKey: string;
-  private runtimeMMsRestrictHashMapErrorCodesKey: string;
 
   private pricesCacheKey: string;
   private marketMakersCacheKey: string;
@@ -115,8 +108,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     this.disabledMMs = new Set(dexHelper.config.data.hashFlowDisabledMMs);
     this.runtimeMMsRestrictHashMapKey =
       `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms`.toLowerCase();
-    this.runtimeMMsRestrictHashMapErrorCodesKey =
-      `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms_error_codes`.toLowerCase();
 
     this.rateFetcher = new RateFetcher(
       this.dexHelper,
@@ -604,7 +595,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}: ${JSON.stringify(rfq)}`;
         this.logger.warn(message);
-        throw new RfqError(message, `${rfq?.error?.code}` as ErrorCode);
+        throw new RfqError(message);
       } else if (!rfq.quotes[0].quoteData) {
         const message = `${this.dexKey}-${
           this.network
@@ -613,7 +604,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing quote data`;
         this.logger.warn(message);
-        throw new RfqError(message, 'MISSING_QUOTE_DATA');
+        throw new RfqError(message);
       } else if (!rfq.quotes[0].signature) {
         const message = `${this.dexKey}-${
           this.network
@@ -622,7 +613,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing signature`;
         this.logger.warn(message);
-        throw new RfqError(message, 'MISSING_SIGNATURE_DATA');
+        throw new RfqError(message);
       }
 
       assert(
@@ -738,13 +729,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           this.logger.warn(
             `${this.dexKey}-${this.network} MM unknown preprocess transaction error: ${e}`,
           );
-          const code =
-            e instanceof RfqError || e instanceof SlippageCheckError
-              ? e?.code || UNKNOWN_ERROR_CODE
-              : UNKNOWN_ERROR_CODE;
-          await this.restrictMM(mm, code).catch(err =>
-            this.logger.warn(`Failed to restrict MM ${mm}: ${err}`),
-          );
+          await this.restrictMM(mm);
         }
       }
 
@@ -752,111 +737,24 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     }
   }
 
-  async restrictMM(mm: string, errorCode: ErrorCode): Promise<void> {
-    const errorCodesRaw = await this.dexHelper.cache.hget(
-      this.runtimeMMsRestrictHashMapErrorCodesKey,
-      mm,
+  async restrictMM(mm: string): Promise<void> {
+    this.logger.warn(
+      `${this.dexKey}-${this.network}: ${mm} was restricted for ${HASHFLOW_MM_RESTRICT_TTL_S} sec. due to fails`,
     );
 
-    const errorCodes: CacheErrorCodesData = Utils.Parse(errorCodesRaw) || {};
-
-    const error = errorCodes?.[errorCode];
+    // We use timestamp for creation date to later discern if it already expired or not
+    await this.dexHelper.cache.hset(
+      this.runtimeMMsRestrictHashMapKey,
+      mm,
+      Date.now().toString(),
+    );
 
-    if (
-      !error ||
-      error.addedDatetimeMS + CONSECUTIVE_ERROR_TIMESPAN_MS < Date.now()
-    ) {
-      this.logger.warn(
-        `${this.dexKey}-${this.network}: First encounter of error code=${errorCode} for ${mm} OR error ocurred outside of threshold, setting up counter`,
-      );
-      const data: CacheErrorCodesData = {
-        ...errorCodes,
-        [errorCode]: {
-          count: 1,
-          addedDatetimeMS: Date.now(),
-        },
-      };
-      await this.dexHelper.cache.hset(
-        this.runtimeMMsRestrictHashMapErrorCodesKey,
-        mm,
-        Utils.Serialize(data),
+    // Expiry cache because it has levels for blacklisted MM
+    this.dexHelper.cache.del(this.dexKey, this.network, 'levels').catch(e => {
+      this.logger.error(
+        `${this.dexKey}-${this.network}: Failed to delete levels cache: ${e.message}`,
       );
-      return;
-    } else {
-      const restrictTTLMs =
-        ERROR_CODE_TO_RESTRICT_TTL[errorCode] ||
-        ERROR_CODE_TO_RESTRICT_TTL[UNKNOWN_ERROR_CODE];
-
-      if (error.count + 1 > CONSECUTIVE_ERROR_THRESHOLD) {
-        this.logger.warn(
-          `${this.dexKey}-${this.network}: ${mm} was restricted for ${
-            restrictTTLMs / 1000
-          } sec. due to ${errorCode} happening ${
-            error.count + 1
-          } times within last ${Math.floor(
-            CONSECUTIVE_ERROR_TIMESPAN_MS / 1000 / 60,
-          )} minutes`,
-        );
-
-        // date added is checked against HASHFLOW_MM_RESTRICT_TTL_S, as a hack we set a date so that it's checked against specific ttls based on error type to not change parsing logic for mms
-        //
-        // Example1: ttl for a particular error is 20 minutes (< default 60 minutes)
-        // Meaning we need to set `addedDatetimeMS` for restrict hash as Date.now() - 40 minutes (diff between default restrict ttl=1h and particular error restrict ttl = 20 minutes). So the `addedDatetimeMS` is in the past, and after 20 minutes mm will not be considered as restricted
-        //
-        // Example 2: ttl for a particular error is 80 minutes (> default 60 minutes)
-        // Meaning we need to set `addedDatetimeMS` for restrict hash as Date.now() + 20 minutes (in the future), then after an hour (default) it'll still be 20 minutes left for restriction to be cleared
-
-        const defaultRestrictTTLMS = Math.floor(
-          HASHFLOW_MM_RESTRICT_TTL_S * 1000,
-        );
-        const dateModifierMS =
-          defaultRestrictTTLMS > restrictTTLMs
-            ? -(defaultRestrictTTLMS - restrictTTLMs)
-            : restrictTTLMs - defaultRestrictTTLMS;
-
-        const date = (Date.now() + dateModifierMS).toString();
-
-        // We use timestamp for creation date to later discern if it already expired or not
-        await this.dexHelper.cache.hset(
-          this.runtimeMMsRestrictHashMapKey,
-          mm,
-          date,
-        );
-
-        // resetting error count
-        const data: CacheErrorCodesData = {
-          ...errorCodes,
-          [errorCode]: {
-            count: 1,
-            addedDatetimeMS: Date.now(),
-          },
-        };
-        await this.dexHelper.cache.hset(
-          this.runtimeMMsRestrictHashMapErrorCodesKey,
-          mm,
-          Utils.Serialize(data),
-        );
-
-        return;
-      } else {
-        const newCount = +error.count + 1;
-        this.logger.warn(
-          `${this.dexKey}-${this.network}: ${mm} Error with code: ${errorCode} happened ${newCount} times (below or equal to the limit: ${CONSECUTIVE_ERROR_THRESHOLD}), updating counter`,
-        );
-        const data: CacheErrorCodesData = {
-          ...errorCodes,
-          [errorCode]: {
-            count: newCount,
-            addedDatetimeMS: error.addedDatetimeMS, // initial date stays
-          },
-        };
-        await this.dexHelper.cache.hset(
-          this.runtimeMMsRestrictHashMapErrorCodesKey,
-          mm,
-          Utils.Serialize(data),
-        );
-      }
-    }
+    });
   }
 
   getCalldataGasCost(poolPrices: PoolPrices<HashflowData>): number | number[] {

package/src/dex/hashflow/types.ts

@@ -1,6 +1,5 @@
 import { Chain, QuoteData } from '@hashflow/taker-js/dist/types/common';
 import { RequestHeaders } from '../../dex-helper';
-import { ERROR_CODE_TO_RESTRICT_TTL, UNKNOWN_ERROR_CODE } from './constants';
 
 export type HashflowData = {
   mm: string;
@@ -17,22 +16,14 @@ export interface PriceLevel {
   p: string;
 }
 
-export class RfqError extends Error {
-  code: ErrorCode;
-  constructor(message: string, code: ErrorCode = UNKNOWN_ERROR_CODE) {
-    super(message);
-    this.code = code;
-  }
-}
+export class RfqError extends Error {}
 
 export enum RFQType {
   RFQT = 0,
   RFQM = 1,
 }
 
-export class SlippageCheckError extends Error {
-  code: ErrorCode = 'SLIPPAGE';
-}
+export class SlippageCheckError extends Error {}
 
 export type HashflowRatesLevel = {
   pair: Record<string, string>;
@@ -72,12 +63,3 @@ export type HashflowRateFetcherConfig = {
     marketMakersCacheTTLSecs: number;
   };
 };
-
-export type ErrorCode = keyof typeof ERROR_CODE_TO_RESTRICT_TTL;
-
-export type CacheErrorCodesData = {
-  [code in ErrorCode]: {
-    addedDatetimeMS: number;
-    count: number;
-  } | null;
-};

package/src/dex/idex.ts

@@ -194,7 +194,7 @@ export interface IDex<
     IDexPooltracker {}
 
 // Defines the static objects of the IDex class
-export interface DexConstructor<
+export interface DexContructor<
   ExchangeData,
   DirectParam = null,
   OptimizedExchangeData = ExchangeData,

package/src/dex/index.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
 import { CurveV2 } from './curve-v2';
-import { IDexTxBuilder, DexConstructor, IDex, IRouteOptimizer } from './idex';
+import { IDexTxBuilder, DexContructor, IDex, IRouteOptimizer } from './idex';
 import { Jarvis } from './jarvis';
 import { JarvisV6 } from './jarvis-v6/jarvis-v6';
 import { StablePool } from './stable-pool';
@@ -87,6 +87,7 @@ import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
 import { PharaohV1 } from './solidly/forks-override/pharaohV1';
 import { EtherFi } from './etherfi';
+import { SDai } from './sdai/sdai';
 
 const LegacyDexes = [
   CurveV2,
@@ -170,6 +171,7 @@ const Dexes = [
   Wombat,
   Swell,
   PharaohV1,
+  SDai,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<
@@ -183,7 +185,7 @@ interface IGetDirectFunctionName {
 
 export class DexAdapterService {
   dexToKeyMap: {
-    [key: string]: LegacyDexConstructor | DexConstructor<any, any, any>;
+    [key: string]: LegacyDexConstructor | DexContructor<any, any, any>;
   } = {};
   directFunctionsNames: string[];
   dexInstances: {

package/src/dex/pancakeswap-v3/config.ts

@@ -69,22 +69,6 @@ export const PancakeswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/45376/exchange-v3-base/version/latest',
     },
   },
-  DackieSwapV3: {
-    [Network.BASE]: {
-      factory: '0x3D237AC6D2f425D2E890Cc99198818cc1FA48870',
-      quoter: '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9',
-      deployer: '0x4f205D69834f9B101b9289F7AFFAc9B77B3fF9b7',
-      router: '0x4030ebafeb76e5fc848891076dfe315993800ba5',
-      supportedFees: [10000n, 2500n, 500n, 100n],
-      stateMulticall: '0xeBF40A40CA3D4310Bf53048F48e860656e1D7C81',
-      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
-      chunksCount: 10,
-      initRetryFrequency: 10,
-      initHash: `0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2`,
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/50473/exchange-clmm/version/latest',
-    },
-  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {

package/src/dex/pancakeswap-v3/pancakeswap-v3.ts

@@ -87,9 +87,7 @@ export class PancakeswapV3
   intervalTask?: NodeJS.Timeout;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(
-      _.pick(PancakeswapV3Config, ['PancakeswapV3', 'DackieSwapV3']),
-    );
+    getDexKeysWithNetwork(_.pick(PancakeswapV3Config, ['PancakeswapV3']));
 
   logger: Logger;
 

package/src/dex/sdai/config.ts

@@ -0,0 +1,28 @@
+import { SDaiParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+import { SwapSide } from '@paraswap/core';
+
+export const SDaiConfig: DexConfigMap<SDaiParams> = {
+  SDai: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
+      daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+      potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: {
+    [side: string]: { name: string; index: number }[];
+  };
+} = {
+  [Network.MAINNET]: {
+    // TODO: uncomment this when SDAI integration got deployed
+    // [SwapSide.SELL]: [{ name: 'Adapter06', index: 2 }],
+    // [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 5 }],
+    [SwapSide.SELL]: [{ name: 'Adapter06', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 4 }],
+  },
+};

package/src/dex/sdai/constants.ts

@@ -0,0 +1,2 @@
+export const SDAI_DEPOSIT_GAS_COST = 165_000;
+export const SDAI_REDEEM_GAS_COST = 90_000;

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

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network } from '../../../constants';
+import { DummyDexHelper } from '../../../dex-helper';
+import { SDaiPoolState } from '../types';
+import { BlockHeader } from 'web3-eth';
+import { ethers } from 'ethers';
+import { SDai } from '../sdai';
+import { SDaiConfig } from '../config';
+import { getOnChainState } from '../utils';
+import { Interface } from '@ethersproject/abi';
+import PotAbi from '../../../abi/maker-psm/pot.json';
+
+const network = Network.MAINNET;
+const dexKey = 'SDai';
+
+const { potAddress } = SDaiConfig[dexKey][network];
+const blockHeaders: Record<number, BlockHeader> = {};
+
+const dexHelper = new DummyDexHelper(network);
+const logger = dexHelper.getLogger(dexKey);
+
+function preprocessField(value: any): string {
+  if (
+    typeof value === 'bigint' ||
+    typeof value === 'number' ||
+    ethers.BigNumber.isBigNumber(value)
+  ) {
+    return value.toString();
+  }
+  return value;
+}
+
+function compareAndLogDifferences<T extends object, Y extends object>(
+  obj1: T,
+  obj2: Y,
+  keyNames: Array<keyof T & keyof Y>,
+  checkEachKey = false,
+) {
+  let isValid = true;
+  let keys = keyNames;
+
+  if (checkEachKey) {
+    // find common keys
+    const keys1 = Object.keys(obj1);
+    const keys2 = new Set(Object.keys(obj2));
+    keys = keys1.filter(key => keys2.has(key)) as Array<keyof T & keyof Y>;
+  }
+
+  for (let fieldName of keys) {
+    const value1 = preprocessField(obj1[fieldName]);
+    const value2 = preprocessField(obj2[fieldName]);
+
+    if (value1 !== value2) {
+      console.log(
+        `${fieldName.toString()} mismatch: actual: ${value1} vs pool: ${value2}`,
+      );
+      isValid = false;
+    }
+  }
+
+  return isValid;
+}
+
+async function isPoolStateEqualToReal(
+  state: SDaiPoolState,
+  blockNumber: number,
+) {
+  const expected = await getOnChainState(
+    dexHelper.multiContract,
+    potAddress,
+    new Interface(PotAbi),
+    blockNumber,
+  );
+
+  const isValidState = compareAndLogDifferences(state, expected, [
+    'rho',
+    'dsr',
+    'dsr',
+  ]);
+
+  return isValidState;
+}
+
+async function checkPoolStateForBlockRange(
+  startBlockNumber: number,
+  endBlockNumber: number,
+): Promise<boolean> {
+  const network = Network.MAINNET;
+  const dexKey = 'SDai';
+  const dexHelper = new DummyDexHelper(network);
+
+  const sdai = new SDai(network, dexKey, dexHelper);
+  const pool = await sdai.eventPool;
+
+  const logsToDispatch = await dexHelper.provider.getLogs({
+    fromBlock: startBlockNumber,
+    toBlock: endBlockNumber,
+    address: potAddress,
+  });
+
+  console.log(logsToDispatch.length);
+
+  // group logs by block number
+  const logsByBlockNumber: Record<number, any[]> = {};
+  for (let log of logsToDispatch) {
+    if (!logsByBlockNumber[log.blockNumber]) {
+      logsByBlockNumber[log.blockNumber] = [];
+    }
+    logsByBlockNumber[log.blockNumber].push(log);
+  }
+
+  const sortedBlocks = Object.keys(logsByBlockNumber)
+    .map(Number)
+    .sort((a, b) => Number(a) - Number(b));
+
+  for (let blockNumber of sortedBlocks) {
+    if (!blockHeaders[blockNumber]) {
+      blockHeaders[blockNumber] = await dexHelper.web3Provider.eth.getBlock(
+        blockNumber,
+      );
+    }
+
+    await pool?.update(logsByBlockNumber[blockNumber], {
+      [blockNumber]: blockHeaders[blockNumber],
+    });
+  }
+
+  const state = pool?.getState(startBlockNumber) as SDaiPoolState;
+  return isPoolStateEqualToReal(state, endBlockNumber);
+}
+
+async function main() {
+  // use findBreakingBlock to find the block where the state is broken
+  // console.log(await findBreakingBlock(startBlockNumber, endBlockNumber));
+  // previously broken block 150502863
+  console.log(await checkPoolStateForBlockRange(19199247 - 10000, 19199247));
+}
+
+main()
+  .then(() => console.log('Done'))
+  .catch(e => console.error(e));

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

@@ -0,0 +1,96 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('sDAI E2E', () => {
+  const dexKey = 'sdai';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'DAI';
+    const tokenBSymbol: string = 'sDAI';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});