@paraswap/dex-lib 2.42.26 → 2.42.27-solidly-v3

package/src/dex/smardex/types.ts

@@ -0,0 +1,69 @@
+import { Address, NumberAsString } from '../../types';
+import {
+  UniswapV2Data,
+  DexParams as UniswapV2DexParams,
+  UniswapPool,
+} from '../uniswap-v2/types';
+import { UniswapV2Pair } from '../uniswap-v2/uniswap-v2';
+import { SmardexEventPool } from './smardex-event-pool';
+
+export interface SmardexPoolState extends SmardexFees {
+  reserves0: string;
+  reserves1: string;
+  fictiveReserves0: string;
+  fictiveReserves1: string;
+  priceAverage0: string;
+  priceAverage1: string;
+  priceAverageLastTimestamp: number;
+}
+
+// export interface SmardexData extends UniswapV2Data {
+export interface SmardexData extends Omit<UniswapV2Data, 'feeFactor'> {
+  deadline: number;
+  receiver: Address;
+}
+
+export type SellOnSmardexParam = [
+  amountIn: NumberAsString,
+  amountOutMin: NumberAsString,
+  path: Address[],
+  receiver: Address,
+  deadline: number,
+];
+
+export type BuyOnSmardexParam = [
+  amountIn: NumberAsString,
+  amountOutMin: NumberAsString,
+  path: Address[],
+  receiver: Address,
+  deadline: number,
+];
+
+export type SmardexParam = SellOnSmardexParam | BuyOnSmardexParam;
+
+export type DexParams = Omit<UniswapV2DexParams, 'feeCode'>;
+
+export type SmardexFees = {
+  feesLP: bigint;
+  feesPool: bigint;
+};
+export interface SmardexPoolOrderedParams extends SmardexFees {
+  fromToken: string;
+  toToken: string;
+  token0: string;
+  token1: string;
+  reserves0: bigint;
+  reserves1: bigint;
+  fictiveReserves0: bigint;
+  fictiveReserves1: bigint;
+  priceAverage0: bigint;
+  priceAverage1: bigint;
+  priceAverageLastTimestamp: number;
+  exchange: string;
+}
+
+export interface SmardexPair extends Omit<UniswapV2Pair, 'pool'> {
+  pool?: SmardexEventPool;
+}
+
+export type SmardexPool = UniswapPool;

package/src/dex/solidly-v3/config.ts

@@ -0,0 +1,64 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+import { Address } from '../../types';
+
+const SUPPORTED_TICK_SPACINGS = [1n, 10n, 50n, 100n];
+
+// Pools that will be initialized on app startup
+// They are added for testing
+export const PoolsToPreload: DexConfigMap<
+  { token0: Address; token1: Address }[]
+> = {
+  SolidlyV3: {
+    [Network.MAINNET]: [
+      {
+        token0: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'.toLowerCase(),
+        token1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'.toLowerCase(),
+      },
+      {
+        token0: '0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0'.toLowerCase(),
+        token1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'.toLowerCase(),
+      },
+      {
+        token0: '0x514910771AF9Ca656af840dff83E8264EcF986CA'.toLowerCase(),
+        token1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'.toLowerCase(),
+      },
+      {
+        token0: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599'.toLowerCase(),
+        token1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'.toLowerCase(),
+      },
+      {
+        token0: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'.toLowerCase(),
+        token1: '0xdAC17F958D2ee523a2206206994597C13D831ec7'.toLowerCase(),
+      },
+      {
+        token0: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'.toLowerCase(),
+        token1: '0xdAC17F958D2ee523a2206206994597C13D831ec7'.toLowerCase(),
+      },
+    ],
+  },
+};
+
+export const SolidlyV3Config: DexConfigMap<DexParams> = {
+  SolidlyV3: {
+    [Network.MAINNET]: {
+      factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
+      quoter: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+      supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
+      stateMulticall: '0xb229563028302AA693EEaD62F80CC331aEDE4e26',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/solidlylabs/solidly-v3',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter04', index: 7 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 3 }],
+  },
+};

package/src/dex/solidly-v3/constants.ts

@@ -0,0 +1,42 @@
+export const UNISWAPV3_TICK_GAS_COST = 10_000; // Ceiled
+export const UNISWAPV3_TICK_BASE_OVERHEAD = 50_000;
+export const UNISWAPV3_POOL_SEARCH_OVERHEAD = 0;
+
+// This is used for price calculation. If out of scope, return 0n
+export const TICK_BITMAP_TO_USE = 4n;
+
+// This is used to check if the state is still valid.
+export const TICK_BITMAP_BUFFER = 8n;
+
+export const MAX_PRICING_COMPUTATION_STEPS_ALLOWED = 128;
+
+export const UNISWAPV3_SUBGRAPH_URL =
+  'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3';
+
+export const UNISWAPV3_EFFICIENCY_FACTOR = 3;
+
+export const ZERO_TICK_INFO = {
+  liquidityGross: 0n,
+  liquidityNet: 0n,
+  initialized: false,
+};
+
+export const ZERO_ORACLE_OBSERVATION = {
+  blockTimestamp: 0n,
+  tickCumulative: 0n,
+  secondsPerLiquidityCumulativeX128: 0n,
+  initialized: false,
+};
+
+export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
+
+export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
+
+export enum DirectMethods {
+  directSell = 'directUniV3Swap',
+  directBuy = 'directUniV3Buy',
+}
+export const MIN_SQRT_RATIO = BigInt('4295128739');
+export const MAX_SQRT_RATIO = BigInt(
+  '1461446703485210103287273052203988822378723970342',
+);

package/src/dex/solidly-v3/contract-math/BitMath.ts

@@ -0,0 +1,90 @@
+import {
+  BI_MAX_UINT128,
+  BI_MAX_UINT16,
+  BI_MAX_UINT32,
+  BI_MAX_UINT64,
+  BI_MAX_UINT8,
+} from '../../../bigint-constants';
+import { _require } from '../../../utils';
+
+export class BitMath {
+  static mostSignificantBit(x: bigint): bigint {
+    _require(x > 0, '', { x }, 'x > 0');
+    let r = 0n;
+
+    if (x >= 0x100000000000000000000000000000000n) {
+      x >>= 128n;
+      r += 128n;
+    }
+    if (x >= 0x10000000000000000n) {
+      x >>= 64n;
+      r += 64n;
+    }
+    if (x >= 0x100000000n) {
+      x >>= 32n;
+      r += 32n;
+    }
+    if (x >= 0x10000n) {
+      x >>= 16n;
+      r += 16n;
+    }
+    if (x >= 0x100n) {
+      x >>= 8n;
+      r += 8n;
+    }
+    if (x >= 0x10n) {
+      x >>= 4n;
+      r += 4n;
+    }
+    if (x >= 0x4n) {
+      x >>= 2n;
+      r += 2n;
+    }
+    if (x >= 0x2n) r += 1n;
+
+    return r;
+  }
+
+  static leastSignificantBit(x: bigint): bigint {
+    _require(x > 0, '', { x }, 'x > 0');
+
+    let r = 255n;
+    if ((x & BI_MAX_UINT128) > 0n) {
+      r -= 128n;
+    } else {
+      x >>= 128n;
+    }
+    if ((x & BI_MAX_UINT64) > 0n) {
+      r -= 64n;
+    } else {
+      x >>= 64n;
+    }
+    if ((x & BI_MAX_UINT32) > 0n) {
+      r -= 32n;
+    } else {
+      x >>= 32n;
+    }
+    if ((x & BI_MAX_UINT16) > 0n) {
+      r -= 16n;
+    } else {
+      x >>= 16n;
+    }
+    if ((x & BI_MAX_UINT8) > 0n) {
+      r -= 8n;
+    } else {
+      x >>= 8n;
+    }
+    if ((x & 0xfn) > 0n) {
+      r -= 4n;
+    } else {
+      x >>= 4n;
+    }
+    if ((x & 0x3n) > 0n) {
+      r -= 2n;
+    } else {
+      x >>= 2n;
+    }
+    if ((x & 0x1n) > 0n) r -= 1n;
+    return r;
+  }
+}

package/src/dex/solidly-v3/contract-math/FixedPoint128.ts

@@ -0,0 +1,3 @@
+export class FixedPoint128 {
+  static readonly Q128 = 0x100000000000000000000000000000000n;
+}

package/src/dex/solidly-v3/contract-math/FixedPoint96.ts

@@ -0,0 +1,4 @@
+export class FixedPoint96 {
+  static readonly RESOLUTION = 96n;
+  static readonly Q96 = 0x1000000000000000000000000n;
+}

package/src/dex/solidly-v3/contract-math/FullMath.ts

@@ -0,0 +1,30 @@
+import { BI_MAX_UINT256 } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+
+export class FullMath {
+  static mulDiv(a: bigint, b: bigint, denominator: bigint) {
+    const result = (a * b) / denominator;
+
+    _require(
+      result <= BI_MAX_UINT256,
+      '',
+      { result, BI_MAX_UINT: BI_MAX_UINT256 },
+      'result <= BI_MAX_UINT',
+    );
+
+    return result;
+  }
+
+  static mulDivRoundingUp(a: bigint, b: bigint, denominator: bigint) {
+    const result = (a * b + denominator - 1n) / denominator;
+
+    _require(
+      result <= BI_MAX_UINT256,
+      '',
+      { result, BI_MAX_UINT: BI_MAX_UINT256 },
+      'result <= BI_MAX_UINT',
+    );
+
+    return result;
+  }
+}

package/src/dex/solidly-v3/contract-math/LiquidityMath.ts

@@ -0,0 +1,17 @@
+import { _require } from '../../../utils';
+
+export class LiquidityMath {
+  static addDelta(x: bigint, y: bigint): bigint {
+    let z;
+    if (y < 0) {
+      const _y = BigInt.asUintN(128, -y);
+      z = x - _y;
+      _require(z < x, 'LS', { z, x, y, _y }, 'z < x');
+    } else {
+      const _y = BigInt.asUintN(128, y);
+      z = x + _y;
+      _require(z >= x, 'LA', { z, x, y, _y }, 'z >= x');
+    }
+    return z;
+  }
+}

package/src/dex/solidly-v3/contract-math/SqrtPriceMath.ts

@@ -0,0 +1,226 @@
+import { BI_MAX_UINT160 } from '../../../bigint-constants';
+import { FixedPoint96 } from './FixedPoint96';
+import { FullMath } from './FullMath';
+import { UnsafeMath } from './UnsafeMath';
+import { _require } from '../../../utils';
+
+export class SqrtPriceMath {
+  static getNextSqrtPriceFromAmount0RoundingUp(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (amount === 0n) return sqrtPX96;
+    const numerator1 =
+      BigInt.asUintN(256, liquidity) << FixedPoint96.RESOLUTION;
+
+    const product = amount * sqrtPX96;
+    if (add) {
+      if (product / amount === sqrtPX96) {
+        const denominator = numerator1 + product;
+        if (denominator >= numerator1) {
+          return BigInt.asUintN(
+            160,
+            FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator),
+          );
+        }
+      }
+      return BigInt.asUintN(
+        160,
+        UnsafeMath.divRoundingUp(numerator1, numerator1 / sqrtPX96 + amount),
+      );
+    } else {
+      _require(
+        product / amount === sqrtPX96 && numerator1 > product,
+        '',
+        { product, amount, sqrtPX96, numerator1 },
+        'product / amount === sqrtPX96 && numerator1 > product',
+      );
+      const denominator = numerator1 - product;
+      return BigInt.asUintN(
+        160,
+        FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator),
+      );
+    }
+  }
+
+  static getNextSqrtPriceFromAmount1RoundingDown(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (add) {
+      const quotient =
+        amount <= BI_MAX_UINT160
+          ? (amount << FixedPoint96.RESOLUTION) / liquidity
+          : FullMath.mulDiv(amount, FixedPoint96.Q96, liquidity);
+      return BigInt.asUintN(160, BigInt.asUintN(256, sqrtPX96) + quotient);
+    } else {
+      const quotient =
+        amount <= BI_MAX_UINT160
+          ? UnsafeMath.divRoundingUp(
+              amount << FixedPoint96.RESOLUTION,
+              liquidity,
+            )
+          : FullMath.mulDivRoundingUp(amount, FixedPoint96.Q96, liquidity);
+
+      _require(
+        sqrtPX96 > quotient,
+        '',
+        { sqrtPX96, quotient },
+        'sqrtPX96 > quotient',
+      );
+      return BigInt.asUintN(160, sqrtPX96 - quotient);
+    }
+  }
+
+  static getNextSqrtPriceFromInput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountIn: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    _require(sqrtPX96 > 0n, '', { sqrtPX96 }, 'sqrtPX96 > 0n');
+    _require(liquidity > 0n, '', { liquidity }, 'liquidity > 0n');
+
+    return zeroForOne
+      ? SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        )
+      : SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        );
+  }
+
+  static getNextSqrtPriceFromOutput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountOut: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    _require(sqrtPX96 > 0n, '', { sqrtPX96 }, 'sqrtPX96 > 0n');
+    _require(liquidity > 0n, '', { liquidity }, 'liquidity > 0n');
+
+    return zeroForOne
+      ? SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        )
+      : SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        );
+  }
+
+  static getAmount0Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+
+    const numerator1 =
+      BigInt.asUintN(256, liquidity) << FixedPoint96.RESOLUTION;
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
+
+    _require(sqrtRatioAX96 > 0, '', { sqrtRatioAX96 }, 'sqrtRatioAX96 > 0');
+
+    return roundUp
+      ? UnsafeMath.divRoundingUp(
+          FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96),
+          sqrtRatioAX96,
+        )
+      : FullMath.mulDiv(numerator1, numerator2, sqrtRatioBX96) / sqrtRatioAX96;
+  }
+
+  static getAmount1Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ) {
+    if (sqrtRatioAX96 > sqrtRatioBX96)
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(
+          liquidity,
+          sqrtRatioBX96 - sqrtRatioAX96,
+          FixedPoint96.Q96,
+        )
+      : FullMath.mulDiv(
+          liquidity,
+          sqrtRatioBX96 - sqrtRatioAX96,
+          FixedPoint96.Q96,
+        );
+  }
+
+  // Overloaded with different argument numbers
+  static _getAmount0DeltaO(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+  ) {
+    return liquidity < 0
+      ? -BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount0Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, -liquidity),
+            false,
+          ),
+        )
+      : BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount0Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, liquidity),
+            true,
+          ),
+        );
+  }
+
+  // Overloaded with different argument numbers
+  static _getAmount1DeltaO(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+  ) {
+    return liquidity < 0
+      ? -BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount1Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, -liquidity),
+            false,
+          ),
+        )
+      : BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount1Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, liquidity),
+            true,
+          ),
+        );
+  }
+}

package/src/dex/solidly-v3/contract-math/SwapMath.ts

@@ -0,0 +1,139 @@
+import { BI_POWS } from '../../../bigint-constants';
+import { FullMath } from './FullMath';
+import { SqrtPriceMath } from './SqrtPriceMath';
+
+export class SwapMath {
+  static computeSwapStep(
+    sqrtRatioCurrentX96: bigint,
+    sqrtRatioTargetX96: bigint,
+    liquidity: bigint,
+    amountRemaining: bigint,
+    feePips: bigint,
+  ): {
+    sqrtRatioNextX96: bigint;
+    amountIn: bigint;
+    amountOut: bigint;
+    feeAmount: bigint;
+  } {
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
+    const exactIn = amountRemaining >= 0n;
+
+    let sqrtRatioNextX96 = 0n;
+    let amountIn = 0n;
+    let amountOut = 0n;
+    let feeAmount = 0n;
+
+    if (exactIn) {
+      const amountRemainingLessFee = FullMath.mulDiv(
+        BigInt.asUintN(256, amountRemaining),
+        BI_POWS[6] - feePips,
+        BI_POWS[6],
+      );
+      amountIn = zeroForOne
+        ? SqrtPriceMath.getAmount0Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            true,
+          )
+        : SqrtPriceMath.getAmount1Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            true,
+          );
+      if (amountRemainingLessFee >= amountIn)
+        sqrtRatioNextX96 = sqrtRatioTargetX96;
+      else
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          amountRemainingLessFee,
+          zeroForOne,
+        );
+    } else {
+      amountOut = zeroForOne
+        ? SqrtPriceMath.getAmount1Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            false,
+          )
+        : SqrtPriceMath.getAmount0Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            false,
+          );
+      if (BigInt.asUintN(256, -amountRemaining) >= amountOut)
+        sqrtRatioNextX96 = sqrtRatioTargetX96;
+      else
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          BigInt.asUintN(256, -amountRemaining),
+          zeroForOne,
+        );
+    }
+
+    const max = sqrtRatioTargetX96 == sqrtRatioNextX96;
+
+    if (zeroForOne) {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              true,
+            );
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              false,
+            );
+    } else {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              true,
+            );
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              false,
+            );
+    }
+
+    // cap the output amount to not exceed the remaining output amount
+    if (!exactIn && amountOut > BigInt.asUintN(256, -amountRemaining)) {
+      amountOut = BigInt.asUintN(256, -amountRemaining);
+    }
+
+    if (exactIn && sqrtRatioNextX96 != sqrtRatioTargetX96) {
+      // we didn't reach the target, so take the remainder of the maximum input as fee
+      feeAmount = BigInt.asUintN(256, amountRemaining) - amountIn;
+    } else {
+      feeAmount = FullMath.mulDivRoundingUp(
+        amountIn,
+        feePips,
+        BI_POWS[6] - feePips,
+      );
+    }
+
+    return { sqrtRatioNextX96, amountIn, amountOut, feeAmount };
+  }
+}