@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/smardex/sdk/errors.ts

@@ -1,18 +0,0 @@
-/**
- * SmardexError class
- *
- * @class SmardexError extends Error
- */
-export default class SmardexError extends Error {
-  /**
-   * Create SmardexError object
-   *
-   * @param {string} message - error message
-   * @param {string} [errorName=SmarDexSDK] - identifier for the error
-   * @returns {SmardexError} SmarDex Error object
-   */
-  constructor(message: string, errorName = 'SmarDexSDK') {
-    super(message);
-    this.name = errorName;
-  }
-}

package/src/dex/smardex/sdk/types.ts

@@ -1,68 +0,0 @@
-import { TradeType } from './constants';
-
-export interface Pair {
-  address?: string;
-  token0: string;
-  token1: string;
-  reserve0: bigint;
-  reserve1: bigint;
-  reserve0LastFictive: bigint;
-  reserve1LastFictive: bigint;
-  priceAverageLastTimestamp: number;
-  priceAverage0: bigint;
-  priceAverage1: bigint;
-  forcedPriceAverageTimestamp?: number;
-  prevReserveFic0?: bigint;
-  prevReserveFic1?: bigint;
-  feesLP: bigint;
-  feesPool: bigint;
-}
-
-export interface CurrencyAmount {
-  currency: string;
-  amount: bigint;
-  amountMax?: bigint;
-  newRes0?: bigint;
-  newRes1?: bigint;
-  newRes0Fic?: bigint;
-  newRes1Fic?: bigint;
-  newPriceAverage0?: bigint;
-  newPriceAverage1?: bigint;
-  forcedPriceAverageTimestamp?: number;
-}
-
-export interface BestTradeOptions {
-  maxNumResults?: number; // how many results to return
-  maxHops?: number; // the maximum number of hops for the swap
-  arbitrage?: boolean; // consider arbitrage loops or not
-}
-
-export interface Route {
-  pairs: Pair[];
-  path: string[];
-  input: string;
-  output: string;
-}
-
-export interface Trade {
-  route: Route;
-  amountIn: CurrencyAmount;
-  amountOut: CurrencyAmount;
-  tradeType: TradeType;
-  priceImpact?: bigint;
-  gasFeesUSD?: bigint;
-  amountInUSD?: bigint;
-  amountOutUSD?: bigint;
-}
-
-export interface GasEstimateData {
-  gasPrice: bigint;
-  gasQuantitiesFirstHop: number;
-  gasQuantitiesAdditionalHop: number;
-  nativeTokenPrice: bigint;
-  nativeTokenDecimals: number;
-  inputTokenPrice: bigint;
-  inputTokenDecimals: number;
-  outputTokenPrice: bigint;
-  outputTokenDecimals: number;
-}

package/src/dex/smardex/sdk/utils.ts

@@ -1,156 +0,0 @@
-import { parseUnits } from 'ethers/lib/utils';
-
-import { CurrencyAmount, Trade } from './types';
-
-// Constants to compute approximate equality
-const APPROX_EQ_PRECISION = 1n;
-const APPROX_EQ_BASE_PRECISION = 1000000n;
-
-/**
- * Computes logarithm in base 2 for a given positive number.
- * Result is rounded down.
- *
- * @param {bigint} value - value to compute the log2
- * @returns {bigint} the log in base 2 of the value, 0 if given 0.
- */
-/* eslint-disable no-param-reassign */
-export function log2(value: bigint): bigint {
-  let result = 0n;
-
-  if (value >> 128n > 0n) {
-    value >>= 128n;
-    result += 128n;
-  }
-
-  if (value >> 64n > 0n) {
-    value >>= 64n;
-    result += 64n;
-  }
-
-  if (value >> 32n > 0n) {
-    value >>= 32n;
-    result += 32n;
-  }
-
-  if (value >> 16n > 0n) {
-    value >>= 16n;
-    result += 16n;
-  }
-
-  if (value >> 8n > 0n) {
-    value >>= 8n;
-    result += 8n;
-  }
-
-  if (value >> 4n > 0n) {
-    value >>= 4n;
-    result += 4n;
-  }
-
-  if (value >> 2n > 0n) {
-    value >>= 2n;
-    result += 2n;
-  }
-
-  if (value >> 1n > 0n) {
-    result += 1n;
-  }
-
-  return result;
-}
-
-/**
- * Computes the square root of a number. If the number is not a perfect square, the value is rounded down.
- * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
- *
- * @param {bigint} value - value to compute the square root
- * @returns {bigint} the square root of the value
- */
-export function sqrt(value: bigint): bigint {
-  if (value === 0n) {
-    return 0n;
-  }
-
-  // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
-  //
-  // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
-  // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
-  //
-  // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
-  // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
-  // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
-  //
-  // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
-  let result = 1n << (log2(value) / 2n);
-
-  // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
-  // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
-  // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
-  // into the expected uint128 result.
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-  result = (result + value / result) >> 1n;
-
-  return result < value / result ? result : value / result;
-}
-
-/**
- * Evaluates the equality of two numbers at a precision of 1/1_000_000
- *
- * @param {bigint} x - value to compare
- * @param {bigint} y - value to compare
- * @returns {boolean} true if numbers are approximatively equal at 1/1_000_000, false otherwise
- */
-export function approxEq(x: bigint, y: bigint): true | false {
-  return x > y
-    ? x < y + (y * APPROX_EQ_PRECISION) / APPROX_EQ_BASE_PRECISION
-    : y < x + (x * APPROX_EQ_PRECISION) / APPROX_EQ_BASE_PRECISION;
-}
-
-/**
- * Evaluates the equality of two ratio numbers at a precision of 1/1_000_000. xNum / xDen ~= yNum / yDen
- *
- * @param {bigint} _xNum - first number numerator
- * @param {bigint} _xDen - first number denominator
- * @param {bigint} _yNum - second number numerator
- * @param {bigint} _yDen - second number denominator
- * @returns {boolean} true if the two ratios are approximatively equal at 1/1_000_000, false otherwise
- */
-export function ratioApproxEq(
-  _xNum: bigint,
-  _xDen: bigint,
-  _yNum: bigint,
-  _yDen: bigint,
-): true | false {
-  return approxEq(_xNum * _yDen, _xDen * _yNum);
-}
-
-/**
- * Computes the ratio of two numbers
- *
- * @param {bigint} numerator - numerator number
- * @param {bigint} denominator - denominator number
- * @param {number} decimals - decimals
- * @returns {bigint} ratio of the two numbers. returns 0 if denominator is 0
- */
-export function priceRatio(
-  numerator: bigint,
-  denominator: bigint,
-  decimals = 18,
-) {
-  if (denominator === 0n) {
-    return 0n;
-  }
-
-  return (
-    BigInt(parseUnits(numerator.toString(), decimals).toString()) / denominator
-  );
-}
-
-export function abs(value: bigint) {
-  return value === -0n || value < 0n ? -value : value;
-}

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

@@ -1,275 +0,0 @@
-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,
-  pairs: { name: string; sellAmount: string; buyAmount: 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]],
-  ]);
-
-  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(
-                tokens[pair[0].name],
-                tokens[pair[1].name],
-                holders[pair[0].name],
-                side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-              );
-            });
-            it(`${pair[1].name} -> ${pair[0].name}`, async () => {
-              await testE2E(
-                tokens[pair[1].name],
-                tokens[pair[0].name],
-                holders[pair[1].name],
-                side === SwapSide.SELL ? pair[1].sellAmount : pair[1].buyAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-              );
-            });
-          });
-        });
-      });
-    }),
-  );
-}
-
-describe('SmarDex E2E', () => {
-  const dexKey = 'SmarDex';
-
-  describe('MAINNET', () => {
-    const network = Network.MAINNET;
-
-    const pairs = [
-      [
-        {
-          name: 'USDT',
-          sellAmount: '1200000000',
-          buyAmount: '120000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '30000000000',
-        },
-      ],
-      [
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '30000000000',
-        },
-        {
-          name: 'ETH',
-          sellAmount: '11000000000000000',
-          buyAmount: '1100000000',
-        },
-      ],
-    ];
-
-    testForNetwork(network, dexKey, pairs);
-  });
-
-  describe('ARBITRUM', () => {
-    const network = Network.ARBITRUM;
-
-    const pairs = [
-      [
-        {
-          name: 'USDC',
-          sellAmount: '1200000000',
-          buyAmount: '120000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '30000000000',
-        },
-      ],
-      [
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '11000000000000000',
-        },
-        {
-          name: 'ETH',
-          sellAmount: '11000000000000000',
-          buyAmount: '11000000',
-        },
-      ],
-    ];
-
-    testForNetwork(network, dexKey, pairs);
-  });
-
-  describe('BSC', () => {
-    const network = Network.BSC;
-
-    const pairs = [
-      [
-        {
-          name: 'USDT',
-          sellAmount: '1200000000000000000000',
-          buyAmount: '300000000000000000000000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '120000000000000000000',
-        },
-      ],
-      [
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '50000000000000000',
-        },
-        {
-          name: 'bBTC',
-          sellAmount: '50000000000000000',
-          buyAmount: '300000000000000000000000',
-        },
-      ],
-      [
-        {
-          name: 'USDT',
-          sellAmount: '1500000000000000000000',
-          buyAmount: '20000000000000000000',
-        },
-        {
-          name: 'BNB',
-          sellAmount: '20000000000000000000',
-          buyAmount: '1500000000000000000000',
-        },
-      ],
-    ];
-
-    testForNetwork(network, dexKey, pairs);
-  });
-
-  describe('POLYGON', () => {
-    const network = Network.POLYGON;
-
-    const pairs = [
-      [
-        {
-          name: 'WETH',
-          sellAmount: '1500000000000000000',
-          buyAmount: '250000000000000000000000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '250000000000000000000000',
-          buyAmount: '1500000000000000000',
-        },
-      ],
-      [
-        {
-          name: 'USDC',
-          sellAmount: '2500000000',
-          buyAmount: '300000000000000000000000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '300000000000000000000000',
-          buyAmount: '2500000000',
-        },
-      ],
-      [
-        {
-          name: 'USDC',
-          sellAmount: '2500000000',
-          buyAmount: '8000000000000000000000',
-        },
-        {
-          name: 'MATIC',
-          sellAmount: '8000000000000000000000',
-          buyAmount: '2500000000',
-        },
-      ],
-      [
-        {
-          name: 'SDEX',
-          sellAmount: '190000000000000000000000',
-          buyAmount: '8000000',
-        },
-        {
-          name: 'WBTC',
-          sellAmount: '8000000',
-          buyAmount: '190000000000000000000000',
-        },
-      ],
-    ];
-
-    testForNetwork(network, dexKey, pairs);
-  });
-
-  describe('BASE', () => {
-    const network = Network.BASE;
-
-    const pairs = [
-      [
-        {
-          name: 'WETH',
-          sellAmount: '1500000000000000000',
-          buyAmount: '2500000000',
-        },
-        {
-          name: 'USDbC',
-          sellAmount: '2500000000',
-          buyAmount: '1500000000000000000',
-        },
-      ],
-      [
-        {
-          name: 'WETH',
-          sellAmount: '1500000000000000000',
-          buyAmount: '250000000000000000000000',
-        },
-        {
-          name: 'SDEX',
-          sellAmount: '250000000000000000000000',
-          buyAmount: '1500000000000000000',
-        },
-      ],
-    ];
-
-    testForNetwork(network, dexKey, pairs);
-  });
-});

package/src/dex/smardex/smardex-event-pool.ts

@@ -1,164 +0,0 @@
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { SmardexFees, SmardexPoolState } from './types';
-import { AbiCoder, Interface } from '@ethersproject/abi';
-import { IDexHelper } from '../../dex-helper';
-import { Address, Log, Logger, Token } from '../../types';
-import { DeepReadonly } from 'ts-essentials';
-import { FEES_LAYER_ONE, TOPICS } from './constants';
-
-const coder = new AbiCoder();
-
-export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState> {
-  constructor(
-    protected poolInterface: Interface,
-    protected dexHelper: IDexHelper,
-    public poolAddress: Address,
-    token0: Token,
-    token1: Token,
-    logger: Logger,
-    protected smardexFeesMultiCallEntry?: {
-      target: string;
-      callData: string;
-    },
-    protected smardexFeesMulticallDecoder?: (values: any[]) => SmardexFees,
-    private isLayerOne = true,
-  ) {
-    super('Smardex', `${token0.address}_${token1.address}`, dexHelper, logger);
-  }
-
-  async fetchPairFeesAndLastTimestamp(blockNumber: number): Promise<{
-    feesLP: bigint;
-    feesPool: bigint;
-    priceAverageLastTimestamp: number;
-  }> {
-    let calldata = [
-      {
-        target: this.poolAddress,
-        callData: this.poolInterface.encodeFunctionData('getPriceAverage', []),
-      },
-    ];
-    if (!this.isLayerOne) {
-      calldata.push(this.smardexFeesMultiCallEntry!);
-    }
-
-    const data: { returnData: any[] } =
-      await this.dexHelper.multiContract.methods
-        .aggregate(calldata)
-        .call({}, blockNumber);
-
-    const priceAverageLastTimestamp = coder.decode(
-      ['uint256', 'uint256', 'uint256'],
-      data.returnData[0],
-    )[2];
-
-    const fees = this.isLayerOne
-      ? FEES_LAYER_ONE
-      : this.smardexFeesMulticallDecoder!(data.returnData[1]);
-    return {
-      feesLP: fees.feesLP,
-      feesPool: fees.feesPool,
-      priceAverageLastTimestamp: priceAverageLastTimestamp.toNumber(),
-    };
-  }
-
-  // This methode overrides previous state with new state.
-  // Problem: Smardex Pair state is updated partially on different events
-  // This is why we must fetch pair's missing state in Events
-  protected async processLog(
-    state: DeepReadonly<SmardexPoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<SmardexPoolState> | null> {
-    if (!Object.values(TOPICS).includes(log.topics[0] as TOPICS)) return null;
-    const event = this.poolInterface.parseLog(log);
-    switch (event.name) {
-      case 'Sync':
-        const fetchedSync = await this.fetchPairFeesAndLastTimestamp(
-          log.blockNumber,
-        );
-        return {
-          reserves0: event.args.reserve0.toString(),
-          reserves1: event.args.reserve1.toString(),
-          fictiveReserves0: event.args.fictiveReserve0.toString(),
-          fictiveReserves1: event.args.fictiveReserve1.toString(),
-          priceAverage0: event.args.priceAverage0.toString(),
-          priceAverage1: event.args.priceAverage1.toString(),
-          priceAverageLastTimestamp: fetchedSync.priceAverageLastTimestamp,
-          feesLP: fetchedSync.feesLP,
-          feesPool: fetchedSync.feesPool,
-        };
-      case 'FeesChanged': // only triggerd on L2
-        return {
-          reserves0: state.reserves0,
-          reserves1: state.reserves1,
-          fictiveReserves0: state.fictiveReserves0,
-          fictiveReserves1: state.fictiveReserves1,
-          priceAverage0: state.priceAverage0,
-          priceAverage1: state.priceAverage1,
-          priceAverageLastTimestamp: state.priceAverageLastTimestamp,
-          feesLP: BigInt(event.args.feesLP),
-          feesPool: BigInt(event.args.feesPool),
-        };
-    }
-    return null;
-  }
-
-  async generateState(
-    blockNumber: number | 'latest' = 'latest',
-  ): Promise<DeepReadonly<SmardexPoolState>> {
-    const coder = new AbiCoder();
-    let calldata = [
-      {
-        target: this.poolAddress,
-        callData: this.poolInterface.encodeFunctionData('getReserves', []),
-      },
-      {
-        target: this.poolAddress,
-        callData: this.poolInterface.encodeFunctionData(
-          'getFictiveReserves',
-          [],
-        ),
-      },
-      {
-        target: this.poolAddress,
-        callData: this.poolInterface.encodeFunctionData('getPriceAverage', []),
-      },
-    ];
-    if (!this.isLayerOne) {
-      calldata.push(this.smardexFeesMultiCallEntry!);
-    }
-
-    const data: { returnData: any[] } =
-      await this.dexHelper.multiContract.methods
-        .aggregate(calldata)
-        .call({}, blockNumber);
-
-    const [reserves0, reserves1] = coder.decode(
-      ['uint256', 'uint256'],
-      data.returnData[0],
-    );
-
-    const [fictiveReserve0, fictiveReserve1] = coder.decode(
-      ['uint256', 'uint256'],
-      data.returnData[1],
-    );
-
-    const [priceAverage0, priceAverage1, priceAverageLastTimestamp] =
-      coder.decode(['uint256', 'uint256', 'uint256'], data.returnData[2]);
-
-    const fees = this.isLayerOne
-      ? FEES_LAYER_ONE
-      : this.smardexFeesMulticallDecoder!(data.returnData[3]);
-
-    return {
-      reserves0: reserves0.toString(),
-      reserves1: reserves1.toString(),
-      fictiveReserves0: fictiveReserve0.toString(),
-      fictiveReserves1: fictiveReserve1.toString(),
-      priceAverage0: priceAverage0.toString(),
-      priceAverage1: priceAverage1.toString(),
-      priceAverageLastTimestamp: priceAverageLastTimestamp.toNumber(),
-      feesLP: fees.feesLP,
-      feesPool: fees.feesPool,
-    };
-  }
-}