@paraswap/dex-lib 2.18.4 → 2.18.6-swaap-v2

package/src/config.ts

@@ -29,6 +29,7 @@ type BaseConfig = {
   rpcPollingBlocksBackToTriggerUpdate: number;
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
+  swaapV2AuthToken?: string;
 };
 
 const baseConfigs: { [network: number]: BaseConfig } = {
@@ -185,8 +186,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_137`]?.split(',') || [],
     adapterAddresses: {
       PolygonAdapter01: '0xE44769f42E1e9592f86B82f206407a8f7C84b4ed',
-      PolygonAdapter02: '0xfb2a3de6c7B8c77b520E3da16021f3D8A4E93168',
-      PolygonBuyAdapter: '0xb2634B3CBc1E401AB3C2743DB44d459C5c9aA662',
+      PolygonAdapter02: '0xa05d8C3F278fC7b20b39Ea7A3035E3aD8D808c78',
+      PolygonBuyAdapter: '0xB11bCA7B01b425afD0743A4D77B4f593883f94C0',
     },
     uniswapV2ExchangeRouterAddress:
       '0xf3938337F7294fEf84e9B2c6D548A93F956Cc281',
@@ -194,6 +195,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 2,
     rpcPollingBlocksBackToTriggerUpdate: 1,
+    swaapV2AuthToken: process.env.API_KEY_SWAAP_V2_AUTH_TOKEN || '',
   },
   [Network.AVALANCHE]: {
     network: Network.AVALANCHE,
@@ -345,6 +347,7 @@ export function generateConfig(network: number): Config {
     rpcPollingBlocksBackToTriggerUpdate:
       baseConfig.rpcPollingBlocksBackToTriggerUpdate,
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
+    swaapV2AuthToken: baseConfig.swaapV2AuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,
   };
 }

package/src/dex/hashflow/hashflow.ts

@@ -279,14 +279,15 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     destToken: Token,
     side: SwapSide,
   ): bigint[] {
-    assert(levels.length > 0, 'Levels should not be empty');
+    if (levels.length > 0) {
+      const firstLevel = levels[0];
+      if (new BigNumber(firstLevel.level).gt(0)) {
+        // Add zero level for price computation
+        levels.unshift({ level: '0', price: firstLevel.price });
+      }
+    }
 
     const outputs = new Array<BigNumber>(amounts.length).fill(BN_0);
-    // FIXME: There is still case when last amount is fillable, but in between
-    // we may have splits that are less than min. amount. I assume that case is very
-    // and not addressing in current fix. If someone will look into that case, just be aware
-    // that it is not addressed
-
     for (const [i, amount] of amounts.entries()) {
       if (amount.isZero()) {
         outputs[i] = BN_0;
@@ -469,10 +470,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     const prices = levelEntries.map(lEntry => {
       const { mm, levels } = lEntry;
 
-      if (levels.length === 0) {
-        return null;
-      }
-
       const divider = getBigNumberPow(
         side === SwapSide.SELL
           ? normalizedSrcToken.decimals
@@ -482,17 +479,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       const amountsRaw = amounts.map(a =>
         new BigNumber(a.toString()).dividedBy(divider),
       );
-      const firstLevelRaw = levels[0];
-      const firstLevelAmountBN = new BigNumber(firstLevelRaw.level);
-
-      if (amountsRaw[amountsRaw.length - 1].lt(firstLevelAmountBN)) {
-        return null;
-      }
-
-      if (firstLevelAmountBN.gt(0)) {
-        // Add zero level for price computation
-        levels.unshift({ level: '0', price: firstLevelRaw.price });
-      }
 
       const unitPrice = this.computePricesFromLevels(
         [BN_1],
@@ -501,7 +487,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         normalizedDestToken,
         side,
       )[0];
-
       const prices = this.computePricesFromLevels(
         amountsRaw,
         levels,
@@ -515,7 +500,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         exchange: this.dexKey,
         data: { mm },
         prices,
-        // Just a mock since we are not using unit amount anymore
         unit: unitPrice,
         poolIdentifier: this.getPoolIdentifier(
           normalizedSrcToken.address,
@@ -526,7 +510,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       } as PoolPrices<HashflowData>;
     });
 
-    return prices.filter((p): p is PoolPrices<HashflowData> => !!p);
+    return prices;
   }
 
   async preProcessTransaction(

package/src/dex/index.ts

@@ -63,6 +63,7 @@ import { MaverickV1 } from './maverick-v1/maverick-v1';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ZyberSwapV3 } from './quickswap/zyberswap-v3';
 import { TraderJoeV2 } from './trader-joe-v2';
+import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
@@ -129,6 +130,7 @@ const Dexes = [
   Hashflow,
   MaverickV1,
   Camelot,
+  SwaapV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -0,0 +1,25 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const SwaapV2Config: DexConfigMap<DexParams> = {
+  SwaapV2: {
+    // Mainnet and Arbitrum will be supported later
+    // [Network.MAINNET]: {
+    //   routerAddress: '0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa',
+    // },
+    // [Network.ARBITRUM]: {
+    //   routerAddress: '0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa',
+    // },
+    [Network.POLYGON]: {
+      routerAddress: '0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 8 }],
+    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 7 }],
+  },
+};

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

@@ -0,0 +1,14 @@
+export const SWAAP_RFQ_PRICES_CACHES_TTL_S = 3;
+export const SWAAP_RFQ_QUOTE_TIMEOUT_MS = 2000;
+
+export const SWAAP_RFQ_API_PRICES_POLLING_INTERVAL_MS = 1000;
+
+export const SWAAP_RFQ_API_URL = 'https://api.swaap.finance/v1/rfq';
+export const SWAAP_RFQ_PRICES_ENDPOINT = 'prices';
+export const SWAAP_RFQ_QUOTE_ENDPOINT = 'quote';
+
+export const GAS_COST_ESTIMATION = 142_000;
+
+export const BATCH_SWAP_SELECTOR = '0x945bcec9';
+
+export const CALLER_SLOT = 160;

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

@@ -0,0 +1,164 @@
+import { IDexHelper } from '../../dex-helper';
+import { Fetcher } from '../../lib/fetcher/fetcher';
+import { validateAndCast } from '../../lib/validators';
+import { Logger, Token, Address } from '../../types';
+import {
+  SwaapV2RateFetcherConfig,
+  SwaapV2PriceLevelsResponse,
+  SwaapV2QuoteResponse,
+  SwaapV2PriceLevels,
+  SwaapV2QuoteRequest,
+  SwaapV2OrderType,
+} from './types';
+import {
+  priceLevelsResponseValidator,
+  getQuoteResponseValidator,
+} from './validators';
+import { getPriceLevelsCacheKey, normalizeTokenAddress } from './utils';
+import { SWAAP_RFQ_QUOTE_TIMEOUT_MS } from './constants';
+import BigNumber from 'bignumber.js';
+import { RequestConfig } from '../../dex-helper/irequest-wrapper';
+
+export class RateFetcher {
+  private rateFetcher: Fetcher<SwaapV2PriceLevelsResponse>;
+  private pricesCacheTTL: number;
+
+  constructor(
+    private dexHelper: IDexHelper,
+    private dexKey: string,
+    private logger: Logger,
+    config: SwaapV2RateFetcherConfig,
+  ) {
+    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
+
+    this.rateFetcher = new Fetcher<SwaapV2PriceLevelsResponse>(
+      dexHelper.httpRequest,
+      {
+        info: {
+          requestOptions: config.rateConfig.pricesReqParams,
+          caster: (data: unknown) => {
+            return validateAndCast<SwaapV2PriceLevelsResponse>(
+              data,
+              priceLevelsResponseValidator,
+            );
+          },
+        },
+        handler: this.handleRatesResponse.bind(this),
+      },
+      config.rateConfig.pricesIntervalMs,
+      logger,
+    );
+  }
+
+  start() {
+    this.rateFetcher.startPolling();
+  }
+
+  stop() {
+    this.rateFetcher.stopPolling();
+  }
+
+  private handleRatesResponse(resp: SwaapV2PriceLevelsResponse): void {
+    if (resp.success) {
+      const levels = Object.keys(resp.levels)
+        .map(pairName => {
+          const pair = resp.levels[pairName];
+          if (!pair) {
+            return;
+          }
+          const levels = resp.levels[pairName];
+
+          if (!levels.asks || !levels.bids) {
+            return;
+          }
+
+          const pairSplit = pairName.split('/');
+
+          const baseAddress = pairSplit[0];
+          const quoteAddress = pairSplit[1];
+          pair.base = normalizeTokenAddress(baseAddress);
+          pair.quote = normalizeTokenAddress(quoteAddress);
+          return pair;
+        })
+        .filter((p: SwaapV2PriceLevels | undefined) => p != null);
+
+      this.dexHelper.cache.setex(
+        this.dexKey,
+        this.dexHelper.config.data.network,
+        `${getPriceLevelsCacheKey(this.dexKey)}`,
+        this.pricesCacheTTL,
+        JSON.stringify(levels),
+      );
+    }
+  }
+
+  async getQuote(
+    networkId: number,
+    _srcToken: Token,
+    _destToken: Token,
+    srcAmount: string,
+    side: SwaapV2OrderType,
+    userAddress: Address,
+    aggregatorRecipient: Address,
+    tolerance: number,
+    requestParameters: RequestConfig,
+  ): Promise<SwaapV2QuoteResponse> {
+    const srcToken = this.dexHelper.config.wrapETH(_srcToken);
+    const destToken = this.dexHelper.config.wrapETH(_destToken);
+
+    if (BigInt(srcAmount) === 0n) {
+      throw new Error('geQuote failed with srcAmount == 0');
+    }
+
+    const _payload: SwaapV2QuoteRequest = {
+      network_id: networkId,
+      origin: userAddress,
+      sender: aggregatorRecipient,
+      recipient: aggregatorRecipient,
+      timestamp: Math.round(Date.now() / 1000),
+      order_type: side,
+      token_in: srcToken.address,
+      token_out: destToken.address,
+      amount: srcAmount,
+      tolerance: tolerance,
+    };
+
+    try {
+      let payload: RequestConfig = {
+        data: _payload,
+        ...requestParameters,
+        timeout: SWAAP_RFQ_QUOTE_TIMEOUT_MS,
+      };
+
+      this.logger.info(
+        'GetQuote Request:',
+        JSON.stringify(payload).replace(/(?:\r\n|\r|\n)/g, ' '),
+      );
+      const { data } = await this.dexHelper.httpRequest.request<unknown>(
+        payload,
+      );
+      this.logger.info(
+        'GetQuote Response: ',
+        JSON.stringify(data).replace(/(?:\r\n|\r|\n)/g, ' '),
+      );
+      const quoteResp = validateAndCast<SwaapV2QuoteResponse>(
+        data,
+        getQuoteResponseValidator,
+      );
+
+      return {
+        id: quoteResp.id,
+        calldata: quoteResp.calldata,
+        router: quoteResp.router,
+        expiration: quoteResp.expiration,
+        amount: quoteResp.amount,
+        guaranteed_price: quoteResp.guaranteed_price,
+        success: quoteResp.success,
+        recipient: quoteResp.recipient,
+      };
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+  }
+}

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

@@ -0,0 +1,199 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const sleepMs: number = 5000;
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  excludeNativeTokenTests: boolean = true,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[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}`, () => {
+            if (excludeNativeTokenTests) {
+              it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+                await testE2E(
+                  tokens[tokenASymbol],
+                  tokens[tokenBSymbol],
+                  holders[tokenASymbol],
+                  side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+                await testE2E(
+                  tokens[tokenBSymbol],
+                  tokens[tokenASymbol],
+                  holders[tokenBSymbol],
+                  side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            } else {
+              it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+                await testE2E(
+                  tokens[nativeTokenSymbol],
+                  tokens[tokenASymbol],
+                  holders[nativeTokenSymbol],
+                  side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+                await testE2E(
+                  tokens[tokenASymbol],
+                  tokens[nativeTokenSymbol],
+                  holders[tokenASymbol],
+                  side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            }
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('SwaapV2 E2E', () => {
+  const dexKey = 'SwaapV2';
+
+  describe('Polygon', () => {
+    const network = Network.POLYGON;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'WETH';
+
+    const tokenAAmount: string = '100000000';
+    const tokenBAmount: string = '10000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
+
+  // Arbitrum will be supported later
+  // describe('Arbitrum', () => {
+  //   const network = Network.ARBITRUM;
+  //
+  //   const tokenASymbol: string = 'ETH';
+  //   const tokenBSymbol: string = 'DAI';
+  //
+  //   const tokenAAmount: string = '100000000';
+  //   const tokenBAmount: string = '1000000000000000000';
+  //   const nativeTokenAmount = '1000000000000000000';
+  //
+  //   testForNetwork(
+  //     network,
+  //     dexKey,
+  //     tokenASymbol,
+  //     tokenBSymbol,
+  //     tokenAAmount,
+  //     tokenBAmount,
+  //     nativeTokenAmount,
+  //   );
+  // });
+
+  // Mainnet will be supported later
+  // describe('Mainnet', () => {
+  //   const network = Network.MAINNET;
+  //   const tokenASymbol: string = 'USDC';
+  //   const tokenBSymbol: string = 'USDT';
+  //
+  //   const tokenAAmount: string = '100000000';
+  //   const tokenBAmount: string = '1000000000000000000';
+  //   const nativeTokenAmount = '1000000000000000000';
+  //
+  //   testForNetwork(
+  //     network,
+  //     dexKey,
+  //     tokenASymbol,
+  //     tokenBSymbol,
+  //     tokenAAmount,
+  //     tokenBAmount,
+  //     nativeTokenAmount,
+  //   );
+  // });
+});

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

@@ -0,0 +1,142 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { SwaapV2 } from './swaap-v2';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+  sleep,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testPricingOnNetwork(
+  swaapV2: SwaapV2,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await swaapV2.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await swaapV2.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (swaapV2.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+}
+
+describe('Swaap V2', function () {
+  const dexKey = 'SwaapV2';
+  let blockNumber: number;
+  let swaapV2: SwaapV2;
+
+  describe('Polygon', () => {
+    const network = Network.POLYGON;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const srcTokenSymbol = 'WETH';
+    const destTokenSymbol = 'USDC';
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+    ];
+
+    const amountsForBuy = [
+      0n,
+      10n * BI_POWS[tokens[destTokenSymbol].decimals],
+      20n * BI_POWS[tokens[destTokenSymbol].decimals],
+    ];
+
+    beforeAll(async () => {
+      swaapV2 = new SwaapV2(network, dexKey, dexHelper);
+      if (swaapV2.initializePricing) {
+        await swaapV2.initializePricing(0);
+        await sleep(5000);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        swaapV2,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.SELL,
+        amountsForSell,
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      await testPricingOnNetwork(
+        swaapV2,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.BUY,
+        amountsForBuy,
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newHashflow = new SwaapV2(network, dexKey, dexHelper);
+      const poolLiquidity = await newHashflow.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        10,
+      );
+      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+      if (!newHashflow.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});