@paraswap/dex-lib 4.0.1 → 4.0.3-Cables.0

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

@@ -26,6 +26,7 @@ import { getTopPoolsApi } from './getTopPoolsApi';
 import balancerRouterAbi from '../../abi/balancer-v3/router.json';
 import balancerBatchRouterAbi from '../../abi/balancer-v3/batch-router.json';
 import { getGasCost } from './getGasCost';
+import { Block } from '@ethersproject/abstract-provider';
 
 const MAX_UINT256 =
   '115792089237316195423570985008687907853269984665640564039457584007913129639935';
@@ -54,6 +55,8 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   updateNewPoolsTimer?: NodeJS.Timeout;
   updateRatesTimer?: NodeJS.Timeout;
 
+  latestBlock?: Block;
+
   constructor(
     readonly network: Network,
     readonly dexKey: string,
@@ -126,6 +129,16 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
     );
   }
 
+  async getBlock(blockNumber: number): Promise<Block> {
+    if (this.latestBlock && this.latestBlock.number === blockNumber) {
+      return this.latestBlock;
+    }
+
+    const block = await this.dexHelper.provider.getBlock(blockNumber);
+    this.latestBlock = block;
+    return block;
+  }
+
   findPoolAddressesWithTokens(
     pools: DeepReadonly<PoolStateMap>,
     tokenA: string,
@@ -188,7 +201,7 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
       }
 
       // This is used to get block timestamp which is needed to calculate Amp if it is updating
-      const block = await this.dexHelper.provider.getBlock(blockNumber);
+      const block = await this.getBlock(blockNumber);
 
       // get up to date pools and state
       const allPoolState = this.eventPools.getState(blockNumber);

package/src/dex/bebop/bebop.ts

@@ -723,7 +723,7 @@ export class Bebop extends SimpleExchange implements IDex<BebopData> {
         }
       }
 
-      if (side == SwapSide.SELL) {
+      if (side === SwapSide.SELL) {
         const requiredAmount = BigInt(optimalSwapExchange.destAmount);
         const quoteAmount = BigInt(
           response.buyTokens[utils.getAddress(destToken.address)].amount,

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

@@ -0,0 +1,207 @@
+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';
+
+const sleepMs: number = 10000;
+const slippage: number = 100;
+
+describe('Cables E2E', () => {
+  const dexKey = 'Cables';
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '500000',
+          buyAmount: '700000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '600000',
+          buyAmount: '850000',
+        },
+      ],
+      [
+        {
+          name: 'WETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '200000000000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '6000000',
+          buyAmount: '8000000',
+        },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  side === SwapSide.SELL
+                    ? tokens[pair[0].name]
+                    : tokens[pair[1].name],
+                  side === SwapSide.SELL
+                    ? tokens[pair[1].name]
+                    : tokens[pair[0].name],
+                  side === SwapSide.SELL
+                    ? holders[pair[0].name]
+                    : holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  slippage,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  side === SwapSide.SELL
+                    ? tokens[pair[1].name]
+                    : tokens[pair[0].name],
+                  side === SwapSide.SELL
+                    ? tokens[pair[0].name]
+                    : tokens[pair[1].name],
+                  side === SwapSide.SELL
+                    ? holders[pair[1].name]
+                    : holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  slippage,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '1000000',
+          buyAmount: '700000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '1000000',
+          buyAmount: '850000',
+        },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  side === SwapSide.SELL
+                    ? tokens[pair[0].name]
+                    : tokens[pair[1].name],
+                  side === SwapSide.SELL
+                    ? tokens[pair[1].name]
+                    : tokens[pair[0].name],
+                  side === SwapSide.SELL
+                    ? holders[pair[0].name]
+                    : holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  slippage,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  side === SwapSide.SELL
+                    ? tokens[pair[1].name]
+                    : tokens[pair[0].name],
+                  side === SwapSide.SELL
+                    ? tokens[pair[0].name]
+                    : tokens[pair[1].name],
+                  side === SwapSide.SELL
+                    ? holders[pair[1].name]
+                    : holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  slippage,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+});

package/src/dex/cables/cables-integration.test.ts

@@ -0,0 +1,391 @@
+/* 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 { Cables } from './cables';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+  sleep,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testPricingOnNetwork(
+  cables: Cables,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await cables.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await cables.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (cables.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+}
+
+describe('Cables', function () {
+  const dexKey = 'Cables';
+  let blockNumber: number;
+  let cables: Cables;
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const tokenASymbol = 'USDC';
+    const tokenBSymbol = 'USDT';
+
+    const amountsForTokenA = [
+      0n,
+      1n * BI_POWS[tokens[tokenASymbol].decimals],
+      2n * BI_POWS[tokens[tokenASymbol].decimals],
+      3n * BI_POWS[tokens[tokenASymbol].decimals],
+      4n * BI_POWS[tokens[tokenASymbol].decimals],
+      5n * BI_POWS[tokens[tokenASymbol].decimals],
+      6n * BI_POWS[tokens[tokenASymbol].decimals],
+      7n * BI_POWS[tokens[tokenASymbol].decimals],
+      8n * BI_POWS[tokens[tokenASymbol].decimals],
+      9n * BI_POWS[tokens[tokenASymbol].decimals],
+      10n * BI_POWS[tokens[tokenASymbol].decimals],
+    ];
+
+    const amountsForTokenB = [
+      0n,
+      1n * BI_POWS[tokens[tokenBSymbol].decimals],
+      2n * BI_POWS[tokens[tokenBSymbol].decimals],
+      3n * BI_POWS[tokens[tokenBSymbol].decimals],
+      4n * BI_POWS[tokens[tokenBSymbol].decimals],
+      5n * BI_POWS[tokens[tokenBSymbol].decimals],
+      6n * BI_POWS[tokens[tokenBSymbol].decimals],
+      7n * BI_POWS[tokens[tokenBSymbol].decimals],
+      8n * BI_POWS[tokens[tokenBSymbol].decimals],
+      9n * BI_POWS[tokens[tokenBSymbol].decimals],
+      10n * BI_POWS[tokens[tokenBSymbol].decimals],
+    ];
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      cables = new Cables(network, dexKey, dexHelper);
+      await cables.initializePricing(blockNumber);
+      await sleep(5000);
+    });
+
+    afterEach(async () => {
+      if (cables.releaseResources) cables.releaseResources();
+      await sleep(5000);
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.SELL,
+        amountsForTokenA,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.BUY,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.SELL,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.BUY,
+        amountsForTokenA,
+      );
+    });
+
+    it.skip('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const cables = new Cables(network, dexKey, dexHelper);
+      const poolLiquidity = await cables.getTopPoolsForToken(
+        tokens[tokenASymbol].address,
+        10,
+      );
+      console.log(
+        `${tokenASymbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+      console.log(
+        `${tokenASymbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      if (!cables.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][tokenASymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const tokenASymbol = 'USDC';
+    const tokenBSymbol = 'USDT';
+
+    const amountsForTokenA = [
+      0n,
+      1n * BI_POWS[tokens[tokenASymbol].decimals],
+      2n * BI_POWS[tokens[tokenASymbol].decimals],
+      3n * BI_POWS[tokens[tokenASymbol].decimals],
+      4n * BI_POWS[tokens[tokenASymbol].decimals],
+      5n * BI_POWS[tokens[tokenASymbol].decimals],
+      6n * BI_POWS[tokens[tokenASymbol].decimals],
+      7n * BI_POWS[tokens[tokenASymbol].decimals],
+      8n * BI_POWS[tokens[tokenASymbol].decimals],
+      9n * BI_POWS[tokens[tokenASymbol].decimals],
+      10n * BI_POWS[tokens[tokenASymbol].decimals],
+    ];
+
+    const amountsForTokenB = [
+      0n,
+      1n * BI_POWS[tokens[tokenBSymbol].decimals],
+      2n * BI_POWS[tokens[tokenBSymbol].decimals],
+      3n * BI_POWS[tokens[tokenBSymbol].decimals],
+      4n * BI_POWS[tokens[tokenBSymbol].decimals],
+      5n * BI_POWS[tokens[tokenBSymbol].decimals],
+      6n * BI_POWS[tokens[tokenBSymbol].decimals],
+      7n * BI_POWS[tokens[tokenBSymbol].decimals],
+      8n * BI_POWS[tokens[tokenBSymbol].decimals],
+      9n * BI_POWS[tokens[tokenBSymbol].decimals],
+      10n * BI_POWS[tokens[tokenBSymbol].decimals],
+    ];
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      cables = new Cables(network, dexKey, dexHelper);
+      await cables.initializePricing(blockNumber);
+      await sleep(5000);
+    });
+
+    afterEach(async () => {
+      if (cables.releaseResources) cables.releaseResources();
+      await sleep(5000);
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.SELL,
+        amountsForTokenA,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.BUY,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.SELL,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        cables,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.BUY,
+        amountsForTokenA,
+      );
+    });
+
+    describe('getTopPoolsForToken', () => {
+      it('USDC getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const tokenSymbol = 'USDC';
+        const cables = new Cables(network, dexKey, dexHelper);
+        const poolLiquidity = await cables.getTopPoolsForToken(
+          tokens[tokenSymbol].address,
+          10,
+        );
+        console.log(
+          `${tokenASymbol} Top Pools:`,
+          JSON.stringify(poolLiquidity, null, 2),
+        );
+
+        if (!cables.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][tokenASymbol].address,
+            dexKey,
+          );
+        }
+      });
+
+      it('WETH getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const tokenSymbol = 'WETH';
+        const cables = new Cables(network, dexKey, dexHelper);
+        const poolLiquidity = await cables.getTopPoolsForToken(
+          tokens[tokenSymbol].address,
+          10,
+        );
+        console.log(
+          `${tokenASymbol} Top Pools:`,
+          JSON.stringify(poolLiquidity, null, 2),
+        );
+
+        if (!cables.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][tokenASymbol].address,
+            dexKey,
+          );
+        }
+      });
+
+      it('ETH getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const tokenSymbol = 'ETH';
+        const cables = new Cables(network, dexKey, dexHelper);
+        const poolLiquidity = await cables.getTopPoolsForToken(
+          tokens[tokenSymbol].address,
+          10,
+        );
+        console.log(
+          `${tokenASymbol} Top Pools:`,
+          JSON.stringify(poolLiquidity, null, 2),
+        );
+
+        if (!cables.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][tokenASymbol].address,
+            dexKey,
+          );
+        }
+      });
+
+      it('ARB getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const tokenSymbol = 'ARB';
+        const cables = new Cables(network, dexKey, dexHelper);
+        const poolLiquidity = await cables.getTopPoolsForToken(
+          tokens[tokenSymbol].address,
+          10,
+        );
+        console.log(
+          `${tokenASymbol} Top Pools:`,
+          JSON.stringify(poolLiquidity, null, 2),
+        );
+
+        if (!cables.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][tokenASymbol].address,
+            dexKey,
+          );
+        }
+      });
+    });
+  });
+});