@paraswap/dex-lib 2.42.26 → 2.42.27

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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,275 @@
+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

@@ -0,0 +1,164 @@
+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,
+    };
+  }
+}