@paraswap/dex-lib 2.42.11 → 2.42.13

package/src/dex/dexalot/dexalot.ts

@@ -395,7 +395,8 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
             .toString(),
         );
         if (isInputQuote) {
-          lQty = (lQty * BigInt(10 ** (baseToken.decimals * 2))) /
+          lQty =
+            (lQty * BigInt(10 ** (baseToken.decimals * 2))) /
             (lPrice * BigInt(10 ** quoteToken.decimals));
           rQty =
             (rQty * BigInt(10 ** (baseToken.decimals * 2))) /
@@ -432,10 +433,6 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
     transferFees?: TransferFeeParams,
   ): Promise<null | ExchangePrices<DexalotData>> {
     try {
-      if (await this.isRestricted()) {
-        return null;
-      }
-
       const normalizedSrcToken = this.normalizeToken(srcToken);
       const normalizedDestToken = this.normalizeToken(destToken);
 
@@ -444,7 +441,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
         return null;
       }
 
-      const pools = limitPools
+      let pools = limitPools
         ? limitPools.filter(
             p =>
               p ===
@@ -455,6 +452,9 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
           )
         : await this.getPoolIdentifiers(srcToken, destToken, side, blockNumber);
 
+      pools = await Promise.all(
+        pools.map(async p => !(await this.isRestrictedPool(p))),
+      ).then(res => pools.filter((_v, i) => res[i]));
       if (pools.length === 0) {
         return null;
       }
@@ -505,14 +505,16 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
         throw new Error(`Empty orderbook for ${pairKey}`);
       }
 
-      const isInputQuote = (clobSide === ClobSide.ASK && side === SwapSide.SELL) || (clobSide === ClobSide.BID && side === SwapSide.BUY);
+      const isInputQuote =
+        (clobSide === ClobSide.ASK && side === SwapSide.SELL) ||
+        (clobSide === ClobSide.BID && side === SwapSide.BUY);
 
       const prices = this.calculateOrderPrice(
         amounts,
         orderbook,
         baseToken,
         quoteToken,
-        isInputQuote
+        isInputQuote,
       );
       const outDecimals =
         clobSide === ClobSide.BID ? baseToken.decimals : quoteToken.decimals;
@@ -579,15 +581,24 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
       const makerToken = normalizedDestToken;
       const takerToken = normalizedSrcToken;
 
+      const isSell = side === SwapSide.SELL;
+      const isBuy = side === SwapSide.BUY;
+
+      const slippageBps = isSell
+        ? BigNumber(1)
+            .minus(options.slippageFactor)
+            .multipliedBy(10000)
+            .toFixed(0)
+        : options.slippageFactor.minus(1).multipliedBy(10000).toFixed(0);
       const rfqParams = {
         makerAsset: ethers.utils.getAddress(makerToken.address),
         takerAsset: ethers.utils.getAddress(takerToken.address),
-        makerAmount:
-          side === SwapSide.BUY ? optimalSwapExchange.destAmount : undefined,
-        takerAmount:
-          side === SwapSide.SELL ? optimalSwapExchange.srcAmount : undefined,
+        makerAmount: isBuy ? optimalSwapExchange.destAmount : undefined,
+        takerAmount: isSell ? optimalSwapExchange.srcAmount : undefined,
         userAddress: options.txOrigin,
         chainid: this.network,
+        partner: options.partner,
+        slippage: slippageBps,
       };
 
       const rfq: RFQResponse = await this.dexHelper.httpRequest.post(
@@ -616,7 +627,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
         order.takerAsset.toLowerCase() === takerToken.address,
         `QuoteData takerAsset=${order.takerAsset} is different from Paraswap takerAsset=${takerToken.address}`,
       );
-      if (side === SwapSide.SELL) {
+      if (isSell) {
         assert(
           order.takerAmount === optimalSwapExchange.srcAmount,
           `QuoteData takerAmount=${order.takerAmount} is different from Paraswap srcAmount=${optimalSwapExchange.srcAmount}`,
@@ -635,7 +646,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
       let isFailOnSlippage = false;
       let slippageErrorMessage = '';
 
-      if (side === SwapSide.SELL) {
+      if (isSell) {
         if (
           BigInt(order.makerAmount) <
           BigInt(
@@ -674,7 +685,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
       let isTooStrictSlippage = false;
       if (
         isFailOnSlippage &&
-        side === SwapSide.SELL &&
+        isSell &&
         new BigNumber(1)
           .minus(slippageFactor)
           .lt(DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)
@@ -682,7 +693,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
         isTooStrictSlippage = true;
       } else if (
         isFailOnSlippage &&
-        side === SwapSide.BUY &&
+        isBuy &&
         slippageFactor
           .minus(1)
           .lt(DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)
@@ -725,10 +736,18 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
             `${this.dexKey}-${this.network}: failed to build transaction on side ${side} with too strict slippage. Skipping restriction`,
           );
         } else {
+          const poolIdentifiers = await this.getPoolIdentifiers(
+            srcToken,
+            destToken,
+            side,
+            0,
+          );
           this.logger.warn(
-            `${this.dexKey}-${this.network}: protocol is restricted`,
+            `${this.dexKey}-${this.network}: protocol is restricted for pools ${poolIdentifiers} due to swap: ${swapIdentifier}`,
+          );
+          await Promise.all(
+            poolIdentifiers.map(async p => await this.restrictPool(p)),
           );
-          await this.restrict();
         }
       }
 
@@ -813,22 +832,29 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
     };
   }
 
-  async restrict(ttl: number = DEXALOT_RESTRICT_TTL_S): Promise<boolean> {
+  getRestrictedPoolKey(poolIdentifier: string): string {
+    return `${DEXALOT_RESTRICTED_CACHE_KEY}-${poolIdentifier}`;
+  }
+
+  async restrictPool(
+    poolIdentifier: string,
+    ttl: number = DEXALOT_RESTRICT_TTL_S,
+  ): Promise<boolean> {
     await this.dexHelper.cache.setex(
       this.dexKey,
       this.network,
-      DEXALOT_RESTRICTED_CACHE_KEY,
+      this.getRestrictedPoolKey(poolIdentifier),
       ttl,
       'true',
     );
     return true;
   }
 
-  async isRestricted(): Promise<boolean> {
+  async isRestrictedPool(poolIdentifier: string): Promise<boolean> {
     const result = await this.dexHelper.cache.get(
       this.dexKey,
       this.network,
-      DEXALOT_RESTRICTED_CACHE_KEY,
+      this.getRestrictedPoolKey(poolIdentifier),
     );
 
     return result === 'true';

package/src/dex/swaap-v2/constants.ts

@@ -20,13 +20,15 @@ export const SWAAP_RFQ_PRICES_ENDPOINT = 'prices';
 
 export const SWAAP_RFQ_QUOTE_ENDPOINT = 'quote';
 
+export const SWAAP_NOTIFY_ENDPOINT = 'notify';
+
 export const SWAAP_RFQ_TOKENS_ENDPOINT = 'tokens';
 
-export const SWAAP_BLACKLIST_TTL_S = 60 * 60 * 24; // 24 hours
+export const SWAAP_403_TTL_S = 60 * 60 * 24; // 24 hours
 
-export const SWAAP_RESTRICT_TTL_S = 60 * 30; // 30 minutes
+export const SWAAP_429_TTL_S = 60 * 60 * 1; // 1 hour
 
-export const SWAAP_RESTRICTED_CACHE_KEY = 'restricted';
+export const SWAAP_POOL_RESTRICT_TTL_S = 60 * 30; // 30 minutes
 
 export const GAS_COST_ESTIMATION = 170_000;
 
@@ -40,3 +42,9 @@ export const SWAAP_ORDER_TYPE_BUY = 2;
 
 export const SWAAP_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION =
   new BigNumber('0.001');
+
+export const SWAAP_NOTIFY_TIMEOUT_MS = 2000;
+
+export const SWAAP_NOTIFICATION_ORIGIN = 'paraswap';
+
+export const SWAAP_BANNED_CODE = 1;

package/src/dex/swaap-v2/rate-fetcher.ts

@@ -11,14 +11,21 @@ import {
   SwaapV2OrderType,
   SwaapV2TokensResponse,
   TokensMap,
+  SwaapV2NotificationRequest,
+  SwaapV2NotificationResponse,
 } from './types';
 import {
   priceLevelsResponseValidator,
   getQuoteResponseValidator,
   getTokensResponseValidator,
+  notifyResponseValidator,
 } from './validators';
 import { normalizeTokenAddress } from './utils';
-import { SWAAP_RFQ_QUOTE_TIMEOUT_MS } from './constants';
+import {
+  SWAAP_RFQ_QUOTE_TIMEOUT_MS,
+  SWAAP_NOTIFY_TIMEOUT_MS,
+  SWAAP_NOTIFICATION_ORIGIN,
+} from './constants';
 import { RequestConfig } from '../../dex-helper/irequest-wrapper';
 
 export class RateFetcher {
@@ -211,4 +218,47 @@ export class RateFetcher {
       throw e;
     }
   }
+
+  async notify(
+    code: number,
+    message: string,
+    requestParameters: RequestConfig,
+  ): Promise<SwaapV2NotificationResponse> {
+    const _payload: SwaapV2NotificationRequest = {
+      origin: SWAAP_NOTIFICATION_ORIGIN,
+      code: code,
+      message: message,
+    };
+
+    try {
+      let payload: RequestConfig = {
+        data: _payload,
+        ...requestParameters,
+        timeout: SWAAP_NOTIFY_TIMEOUT_MS,
+      };
+
+      this.logger.info(
+        'Notify Request:',
+        JSON.stringify(payload).replace(/(?:\r\n|\r|\n)/g, ' '),
+      );
+      const { data } = await this.dexHelper.httpRequest.request<unknown>(
+        payload,
+      );
+      this.logger.info(
+        'Notify Response: ',
+        JSON.stringify(data).replace(/(?:\r\n|\r|\n)/g, ' '),
+      );
+      const notifyResp = validateAndCast<SwaapV2NotificationResponse>(
+        data,
+        notifyResponseValidator,
+      );
+
+      return {
+        success: notifyResp.success,
+      };
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+  }
 }

package/src/dex/swaap-v2/swaap-v2.ts

@@ -11,7 +11,13 @@ import {
   OptimalSwapExchange,
   PreprocessTransactionOptions,
 } from '../../types';
-import { SwapSide, Network, MAX_INT, MAX_UINT } from '../../constants';
+import {
+  SwapSide,
+  Network,
+  MAX_INT,
+  MAX_UINT,
+  CACHE_PREFIX,
+} from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
 import { getDexKeysWithNetwork, isAxiosError } from '../../utils';
 import { IDex } from '../idex';
@@ -23,6 +29,7 @@ import {
   SwaapV2APIParameters,
   SwaapV2QuoteError,
   TokensMap,
+  SwaapV2NotificationResponse,
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, SwaapV2Config } from './config';
@@ -41,10 +48,10 @@ import {
   GAS_COST_ESTIMATION,
   BATCH_SWAP_SELECTOR,
   CALLER_SLOT,
-  SWAAP_BLACKLIST_TTL_S,
+  SWAAP_403_TTL_S,
+  SWAAP_429_TTL_S,
   SWAAP_RFQ_TOKENS_ENDPOINT,
-  SWAAP_RESTRICT_TTL_S,
-  SWAAP_RESTRICTED_CACHE_KEY,
+  SWAAP_POOL_RESTRICT_TTL_S,
   SWAAP_RFQ_API_TOKENS_POLLING_INTERVAL_MS,
   SWAAP_RFQ_TOKENS_CACHES_TTL_S,
   SWAAP_PRICES_CACHE_KEY,
@@ -52,6 +59,8 @@ import {
   SWAAP_ORDER_TYPE_SELL,
   SWAAP_ORDER_TYPE_BUY,
   SWAAP_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION,
+  SWAAP_BANNED_CODE,
+  SWAAP_NOTIFY_ENDPOINT,
 } from './constants';
 import { getPoolIdentifier, normalizeTokenAddress, getPairName } from './utils';
 import { Method } from '../../dex-helper/irequest-wrapper';
@@ -71,6 +80,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
   private rateFetcher: RateFetcher;
   private swaapV2AuthToken: string;
   private tokensMap: TokensMap = {};
+  private runtimeMMsRestrictHashMapKey: string;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(SwaapV2Config);
@@ -113,6 +123,9 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         },
       },
     );
+
+    this.runtimeMMsRestrictHashMapKey =
+      `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms`.toLowerCase();
   }
 
   async initializePricing(blockNumber: number): Promise<void> {
@@ -298,22 +311,22 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     blockNumber: number,
     limitPools?: string[],
   ): Promise<null | ExchangePrices<SwaapV2Data>> {
+    const normalizedSrcToken = this.normalizeToken(srcToken);
+    const normalizedDestToken = this.normalizeToken(destToken);
+
+    const requestedPoolIdentifier: string = getPoolIdentifier(
+      this.dexKey,
+      normalizedSrcToken.address,
+      normalizedDestToken.address,
+    );
+
     try {
-      if (await this.isRestricted()) {
+      if (await this.isRestrictedPool(requestedPoolIdentifier)) {
         return null;
       }
 
       this.tokensMap = (await this.getCachedTokens()) || {};
 
-      const normalizedSrcToken = this.normalizeToken(srcToken);
-      const normalizedDestToken = this.normalizeToken(destToken);
-
-      const requestedPoolIdentifier: string = getPoolIdentifier(
-        this.dexKey,
-        normalizedSrcToken.address,
-        normalizedDestToken.address,
-      );
-
       if (normalizedSrcToken.address === normalizedDestToken.address) {
         return null;
       }
@@ -561,11 +574,13 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         { deadline: minDeadline },
       ];
     } catch (e) {
-      if (
-        isAxiosError(e) &&
-        (e.response?.status === 403 || e.response?.status === 429)
-      ) {
-        await this.setBlacklist(options.txOrigin);
+      if (isAxiosError(e) && e.response?.status === 403) {
+        await this.setBlacklist(options.txOrigin, SWAAP_403_TTL_S);
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: Encountered blacklisted user=${options.txOrigin}. Adding to local blacklist cache`,
+        );
+      } else if (isAxiosError(e) && e.response?.status === 429) {
+        await this.setBlacklist(options.txOrigin, SWAAP_429_TTL_S);
         this.logger.warn(
           `${this.dexKey}-${this.network}: Encountered restricted user=${options.txOrigin}. Adding to local blacklist cache`,
         );
@@ -578,7 +593,16 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
           this.logger.warn(
             `${this.dexKey}-${this.network}: protocol is restricted`,
           );
-          await this.restrict();
+          const poolIdentifier = getPoolIdentifier(
+            this.dexKey,
+            normalizedSrcToken.address,
+            normalizedDestToken.address,
+          );
+          var message = 'Unknown error';
+          if (e instanceof Error) {
+            message = `${e.name}: ${e.message}`;
+          }
+          await this.restrictPool(message, poolIdentifier);
         }
       }
 
@@ -586,25 +610,45 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     }
   }
 
-  async restrict(ttl: number = SWAAP_RESTRICT_TTL_S): Promise<boolean> {
-    await this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      SWAAP_RESTRICTED_CACHE_KEY,
-      ttl,
-      'true',
+  async restrictPool(message: string, poolIdentifier: string): Promise<void> {
+    this.logger.warn(
+      `${this.dexKey}-${this.network}: ${poolIdentifier} was restricted for ${SWAAP_POOL_RESTRICT_TTL_S} sec. due to fails`,
     );
-    return true;
-  }
 
-  async isRestricted(): Promise<boolean> {
-    const result = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      SWAAP_RESTRICTED_CACHE_KEY,
+    // We use timestamp for creation date to later discern if it already expired or not
+    await this.dexHelper.cache.hset(
+      this.runtimeMMsRestrictHashMapKey,
+      poolIdentifier,
+      Date.now().toString(),
     );
 
-    return result === 'true';
+    this.rateFetcher
+      .notify(SWAAP_BANNED_CODE, message, this.getNotifyReqParams())
+      .then((answer: SwaapV2NotificationResponse) => {
+        if (answer.success) {
+          this.logger.info(`Successfully notified Swaap API`);
+        } else {
+          this.logger.error(`Swaap API was not successfully notified`);
+        }
+      })
+      .catch(e => {
+        // Must never happen
+        this.logger.error(`Swaap API notification failed: ${e}`);
+      });
+  }
+
+  async isRestrictedPool(poolIdentifier: string): Promise<boolean> {
+    const expirationThreshold = Date.now() - SWAAP_POOL_RESTRICT_TTL_S * 1000;
+    const createdAt = await this.dexHelper.cache.hget(
+      this.runtimeMMsRestrictHashMapKey,
+      poolIdentifier,
+    );
+    const wasNotRestricted = createdAt === null;
+    if (wasNotRestricted) {
+      return false;
+    }
+    const restrictionExpired = +createdAt < expirationThreshold;
+    return !restrictionExpired;
   }
 
   async isBlacklisted(txOrigin: Address): Promise<boolean> {
@@ -622,7 +666,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
 
   async setBlacklist(
     txOrigin: Address,
-    ttl: number = SWAAP_BLACKLIST_TTL_S,
+    ttl: number = SWAAP_403_TTL_S,
   ): Promise<boolean> {
     await this.dexHelper.cache.setex(
       this.dexKey,
@@ -866,10 +910,6 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
-    if (await this.isRestricted()) {
-      return [];
-    }
-
     this.tokensMap = (await this.getCachedTokens()) || {};
     const normalizedTokenAddress = normalizeTokenAddress(tokenAddress);
 
@@ -880,12 +920,22 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     }
 
     return Object.keys(pLevels)
-      .filter((pair: string) => {
+      .filter(async (pair: string) => {
         const { base, quote } = pLevels[pair];
 
-        return (
-          normalizedTokenAddress === base || normalizedTokenAddress === quote
+        const levelDoesNotIncludeToken =
+          normalizedTokenAddress !== base && normalizedTokenAddress !== quote;
+        if (levelDoesNotIncludeToken) {
+          return false;
+        }
+
+        const poolIdentifier: string = getPoolIdentifier(
+          this.dexKey,
+          base,
+          quote,
         );
+        const isRestrictedPool = await this.isRestrictedPool(poolIdentifier);
+        return !isRestrictedPool;
       })
       .map((pair: string) => {
         return {
@@ -924,6 +974,10 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     return this.getAPIReqParams(SWAAP_RFQ_QUOTE_ENDPOINT, 'POST');
   }
 
+  getNotifyReqParams(): SwaapV2APIParameters {
+    return this.getAPIReqParams(SWAAP_NOTIFY_ENDPOINT, 'POST');
+  }
+
   getTokensReqParams(): SwaapV2APIParameters {
     return this.getAPIReqParams(SWAAP_RFQ_TOKENS_ENDPOINT, 'GET');
   }

package/src/dex/swaap-v2/types.ts

@@ -93,3 +93,13 @@ export type SwaapV2APIParameters = {
 export type TokensMap = {
   [address: string]: Token;
 };
+
+export type SwaapV2NotificationRequest = {
+  origin: string;
+  code: number;
+  message: string;
+};
+
+export type SwaapV2NotificationResponse = {
+  success: boolean;
+};

package/src/dex/swaap-v2/utils.ts

@@ -1,32 +1,25 @@
 import { Address } from '../../types';
-import { CACHE_PREFIX, ETHER_ADDRESS, NULL_ADDRESS } from '../../constants';
+import { ETHER_ADDRESS, NULL_ADDRESS } from '../../constants';
 
 export const getIdentifierPrefix = (
   dexKey: string,
-  srcAddress: Address,
-  destAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
 ) => {
-  return `${dexKey}_${getPairName(srcAddress, destAddress)}`.toLowerCase();
+  return `${dexKey}_${getPairName(tokenA, tokenB)}`.toLowerCase();
 };
 
-export const getPairName = (srcAddress: Address, destAddress: Address) => {
-  const sortedAddresses =
-    srcAddress < destAddress
-      ? [srcAddress, destAddress]
-      : [destAddress, srcAddress];
+export const getPairName = (tokenA: Address, tokenB: Address) => {
+  const sortedAddresses = tokenA < tokenB ? [tokenA, tokenB] : [tokenB, tokenA];
   return `${sortedAddresses[0]}_${sortedAddresses[1]}`.toLowerCase();
 };
 
 export const getPoolIdentifier = (
   dexKey: string,
-  srcAddress: Address,
-  destAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
 ) => {
-  return `${getIdentifierPrefix(
-    dexKey,
-    srcAddress,
-    destAddress,
-  )}`.toLowerCase();
+  return `${getIdentifierPrefix(dexKey, tokenA, tokenB)}`.toLowerCase();
 };
 
 export const normalizeTokenAddress = (address: string): string => {

package/src/dex/swaap-v2/validators.ts

@@ -126,3 +126,9 @@ export const getQuoteResponseValidator = joi
     success: joi.boolean().required(),
   })
   .unknown(true);
+
+export const notifyResponseValidator = joi
+  .object({
+    success: joi.boolean().required(),
+  })
+  .unknown(true);