@paraswap/dex-lib 3.8.21 → 3.8.22-infusion

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

@@ -0,0 +1,232 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper';
+import { Network, SwapSide } from '../../constants';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { BI_POWS } from '../../bigint-constants';
+import { Infusion } from './infusion';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Interface, Result } from '@ethersproject/abi';
+import infusionPairABI from '../../abi/infusion/InfusionPair.json';
+
+const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
+const amounts6 = [0n, BI_POWS[6], 2000000n];
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+  tokenIn: string,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [amount, tokenIn]),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    return BigInt(parsed[0]._hex);
+  });
+}
+
+const constructCheckOnChainPricing =
+  (dexHelper: DummyDexHelper) =>
+  async (
+    infusion: Infusion,
+    funcName: string,
+    blockNumber: number,
+    prices: bigint[],
+    exchangeAddress: string,
+    tokenIn: string,
+    amounts: bigint[],
+  ) => {
+    const readerIface = new Interface(infusionPairABI as any);
+
+    const readerCallData = getReaderCalldata(
+      exchangeAddress,
+      readerIface,
+      amounts.slice(1),
+      funcName,
+      tokenIn,
+    );
+
+    const readerResult = (
+      await dexHelper.multiContract.methods
+        .aggregate(readerCallData)
+        .call({}, blockNumber)
+    ).returnData;
+    const expectedPrices = [0n].concat(
+      decodeReaderResult(readerResult, readerIface, funcName),
+    );
+
+    console.log('ON-CHAIN PRICES: ', expectedPrices);
+
+    expect(prices.map(p => p.toString())).toEqual(
+      expectedPrices.map(p => p.toString()),
+    );
+  };
+
+describe('Infusion integration tests', () => {
+  describe('Base', () => {
+    const network = Network.BASE;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('Infusion', () => {
+      const dexKey = 'Infusion';
+      const infusion = new Infusion(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'WETH';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await infusion.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await infusion.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              infusion,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const dexHelper = new DummyDexHelper(Network.BASE);
+          const infusion = new Infusion(Network.BASE, dexKey, dexHelper);
+
+          const poolLiquidity = await infusion.getTopPoolsForToken(
+            '0x4200000000000000000000000000000000000006',
+            10,
+          );
+          console.log('WETH Top Pools:', poolLiquidity);
+
+          checkPoolsLiquidity(
+            poolLiquidity,
+            '0x4200000000000000000000000000000000000006',
+            dexKey,
+          );
+        });
+      });
+
+      describe('Curve like stable pool', function () {
+        const TokenASymbol = 'USDbC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'USDC';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts6;
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await infusion.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await infusion.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              infusion,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const dexHelper = new DummyDexHelper(Network.BASE);
+          const infusion = new Infusion(Network.BASE, dexKey, dexHelper);
+
+          const poolLiquidity = await infusion.getTopPoolsForToken(
+            '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+            10,
+          );
+          console.log('WETH Top Pools:', poolLiquidity);
+
+          checkPoolsLiquidity(
+            poolLiquidity,
+            '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+            dexKey,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/infusion/infusion-stable-pool.ts

@@ -0,0 +1,91 @@
+import { BI_POWS } from '../../bigint-constants';
+import { RESERVE_LIMIT } from '../uniswap-v2/uniswap-v2';
+import { InfusionPoolOrderedParams } from './types';
+
+const e18 = BI_POWS[18];
+
+function _k(
+  x: bigint,
+  y: bigint,
+  decimals0: bigint,
+  decimals1: bigint,
+): bigint {
+  const _x = (x * e18) / decimals0;
+  const _y = (y * e18) / decimals1;
+  const _a = (_x * _y) / e18;
+  const _b = (_x * _x) / e18 + (_y * _y) / e18;
+  // x3y+y3x >= k
+  return (_a * _b) / e18;
+}
+
+function _f(x0: bigint, y: bigint): bigint {
+  return (
+    (x0 * ((((y * y) / e18) * y) / e18)) / e18 +
+    (((((x0 * x0) / e18) * x0) / e18) * y) / e18
+  );
+}
+
+function _d(x0: bigint, y: bigint): bigint {
+  return (3n * x0 * ((y * y) / e18)) / e18 + (((x0 * x0) / e18) * x0) / e18;
+}
+
+function _getY(x0: bigint, xy: bigint, y: bigint): bigint {
+  for (let i = 0; i < 255; i++) {
+    const yPrev = y;
+    const k = _f(x0, y);
+    if (k < xy) {
+      const dy = ((xy - k) * e18) / _d(x0, y);
+      y = y + dy;
+    } else {
+      const dy = ((k - xy) * e18) / _d(x0, y);
+      y = y - dy;
+    }
+    if (_closeTo(y, yPrev, 1n)) {
+      break;
+    }
+  }
+  return y;
+}
+
+function _closeTo(a: bigint, b: bigint, target: bigint) {
+  if (a > b) {
+    if (a - b <= target) {
+      return true;
+    }
+  } else {
+    if (b - a <= target) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export class InfusionStablePool {
+  static async getSellPrice(
+    priceParams: InfusionPoolOrderedParams,
+    srcAmount: bigint,
+    feeFactor: number,
+  ): Promise<bigint> {
+    const { reservesIn, reservesOut, decimalsIn, decimalsOut, fee } =
+      priceParams;
+
+    // FIXME: some dexes use uint112 others use uint256
+    if (BigInt(reservesIn) + srcAmount > RESERVE_LIMIT) {
+      return 0n;
+    }
+
+    const amountIn = srcAmount - (srcAmount * BigInt(fee)) / BigInt(feeFactor);
+
+    const reservesInN = BigInt(reservesIn);
+    const reservesOutN = BigInt(reservesOut);
+    const decimalsInN = 10n ** BigInt(decimalsIn);
+    const decimalsOutN = 10n ** BigInt(decimalsOut);
+
+    const xy = _k(reservesInN, reservesOutN, decimalsInN, decimalsOutN);
+    const reserveA = (reservesInN * e18) / decimalsInN;
+    const reserveB = (reservesOutN * e18) / decimalsOutN;
+    const amountInNorm = (amountIn * e18) / decimalsInN;
+    const y = reserveB - _getY(amountInNorm + reserveA, xy, reserveB);
+    return (y * decimalsOutN) / e18;
+  }
+}