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

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

@@ -0,0 +1,156 @@
+import { BigNumber, BytesLike } from 'ethers';
+import { NumberAsString } from '../../types';
+import { Address } from '../../types';
+import { AbiItem } from 'web3-utils';
+import { MultiResult } from '../../lib/multi-wrapper';
+
+export type TickInfo = {
+  liquidityGross: bigint;
+  liquidityNet: bigint;
+  initialized: boolean;
+};
+
+export type Slot0 = {
+  sqrtPriceX96: bigint;
+  tick: bigint;
+  fee: bigint;
+};
+
+export type PoolState = {
+  pool: string;
+  blockTimestamp: bigint;
+  tickSpacing: bigint;
+  slot0: Slot0;
+  liquidity: bigint;
+  maxLiquidityPerTick: bigint;
+  tickBitmap: Record<NumberAsString, bigint>;
+  ticks: Record<NumberAsString, TickInfo>;
+  isValid: boolean;
+  startTickBitmap: bigint;
+  lowestKnownTick: bigint;
+  highestKnownTick: bigint;
+  balance0: bigint;
+  balance1: bigint;
+};
+
+export type SolidlyV3Data = {
+  zeroForOne: boolean;
+  poolAddress: string;
+  isApproved?: boolean;
+};
+
+export type DecodeStateMultiCallFunc = (
+  result: MultiResult<BytesLike> | BytesLike,
+) => DecodedStateMultiCallResultWithRelativeBitmaps;
+
+export type DexParams = {
+  quoter: Address;
+  factory: Address;
+  stateMulticall: Address;
+  supportedTickSpacings: bigint[];
+  chunksCount: number;
+  initRetryFrequency: number;
+  deployer?: Address;
+  subgraphURL: string;
+  initHash: string;
+  stateMultiCallAbi?: AbiItem[];
+  decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
+};
+
+export type UniswapV3SimpleSwapSellParam = {
+  path: string;
+  recipient: Address;
+  deadline: string;
+  amountIn: NumberAsString;
+  amountOutMinimum: NumberAsString;
+};
+
+export type UniswapV3SimpleSwapBuyParam = {
+  path: string;
+  recipient: Address;
+  deadline: string;
+  amountOut: NumberAsString;
+  amountInMaximum: NumberAsString;
+};
+
+export type UniswapV3SimpleSwapParams =
+  | UniswapV3SimpleSwapSellParam
+  | UniswapV3SimpleSwapBuyParam;
+
+export type SolidlyV3SimpleSwapParams = {
+  recipient: string;
+  zeroForOne: boolean;
+  amountSpecified: NumberAsString;
+  sqrtPriceLimitX96: NumberAsString;
+};
+
+export type UniswapV3Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  deadline: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  beneficiary: Address,
+  path: string,
+  permit: string,
+  uuid: string,
+];
+
+export enum UniswapV3Functions {
+  exactInput = 'exactInput',
+  exactOutput = 'exactOutput',
+}
+
+export type TickInfoMappings = {
+  index: number;
+  value: TickInfo;
+};
+
+export type TickBitMapMappings = {
+  index: number;
+  value: bigint;
+};
+
+export type OutputResult = {
+  outputs: bigint[];
+  tickCounts: number[];
+};
+
+// Just rewrote every type with BigNumber basically
+
+export type TickBitMapMappingsWithBigNumber = {
+  index: number;
+  value: BigNumber;
+};
+
+export type TickInfoWithBigNumber = {
+  initialized: boolean;
+  liquidityGross: BigNumber;
+  liquidityNet: BigNumber;
+};
+
+export type TickInfoMappingsWithBigNumber = {
+  index: number;
+  value: TickInfoWithBigNumber;
+};
+
+export type DecodedStateMultiCallResultWithRelativeBitmaps = {
+  pool: Address;
+  blockTimestamp: BigNumber;
+  slot0: {
+    sqrtPriceX96: BigNumber;
+    tick: number;
+    fee: number;
+    unlocked: boolean;
+  };
+  liquidity: BigNumber;
+  tickSpacing: number;
+  maxLiquidityPerTick: BigNumber;
+  tickBitmap: TickBitMapMappingsWithBigNumber[];
+  ticks: TickInfoMappingsWithBigNumber[];
+};

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

@@ -0,0 +1,71 @@
+import { BytesLike, ethers } from 'ethers';
+import { assert } from 'ts-essentials';
+import { extractSuccessAndValue } from '../../lib/decoders';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { DexConfigMap } from '../../types';
+import {
+  DexParams,
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+} from './types';
+
+export function getUniswapV3DexKey(UniswapV3Config: DexConfigMap<DexParams>) {
+  const UniswapV3Keys = Object.keys(UniswapV3Config);
+  if (UniswapV3Keys.length !== 1) {
+    throw new Error(
+      `UniswapV3 key in UniswapV3Config is not unique. Update relevant places (optimizer) or fix config issue. Received: ${JSON.stringify(
+        UniswapV3Config,
+        (_0, value) => (typeof value === 'bigint' ? value.toString() : value),
+      )}`,
+    );
+  }
+
+  return UniswapV3Keys[0].toLowerCase();
+}
+
+export function decodeStateMultiCallResultWithRelativeBitmaps(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedStateMultiCallResultWithRelativeBitmaps {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeStateMultiCallResultWithRelativeBitmaps failed to get decodable result: ${result}`,
+  );
+
+  const decoded = ethers.utils.defaultAbiCoder.decode(
+    [
+      // I don't want to pass here any interface, so I just use it in ethers format
+      `
+      tuple(
+        address pool,
+        uint256 blockTimestamp,
+        tuple(
+          uint160 sqrtPriceX96,
+          int24 tick,
+          uint24 fee,
+          bool unlocked,
+        ) slot0,
+        uint128 liquidity,
+        int24 tickSpacing,
+        uint128 maxLiquidityPerTick,
+        tuple(
+          int16 index,
+          uint256 value,
+        )[] tickBitmap,
+        tuple(
+          int24 index,
+          tuple(
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            bool initialized,
+          ) value,
+        )[] ticks
+      )
+    `,
+    ],
+    toDecode,
+  )[0];
+  // This conversion is not precise, because when we decode, we have more values
+  // But I typed only the ones that are used later
+  return decoded as DecodedStateMultiCallResultWithRelativeBitmaps;
+}

package/src/dex/uniswap-v3/contract-math/Oracle.ts

@@ -1,226 +1,226 @@
 import {
-  OracleObservation,
-  OracleObservationCandidates,
-  PoolState,
+    OracleObservation,
+    OracleObservationCandidates,
+    PoolState,
 } from '../types';
 import { _require } from '../../../utils';
 import { DeepReadonly } from 'ts-essentials';
 import { ZERO_ORACLE_OBSERVATION } from '../constants';
 
 function replaceUndefinedObservationWithZero(state: PoolState, index: number) {
-  if (state.observations[index] === undefined) {
-    state.observations[index] = { ...ZERO_ORACLE_OBSERVATION };
-  }
+    if (state.observations[index] === undefined) {
+        state.observations[index] = { ...ZERO_ORACLE_OBSERVATION };
+    }
 }
 
 export class Oracle {
-  static transform(
-    state: DeepReadonly<PoolState>,
-    last: OracleObservation,
-    blockTimestamp: bigint,
-    tick: bigint,
-    liquidity: bigint,
-  ): OracleObservation {
-    const delta = blockTimestamp - last.blockTimestamp;
-    return {
-      blockTimestamp: state.blockTimestamp,
-      tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
-      secondsPerLiquidityCumulativeX128:
-        last.secondsPerLiquidityCumulativeX128 +
-        (BigInt.asUintN(160, delta) << 128n) /
-          (liquidity > 0n ? liquidity : 1n),
-      initialized: true,
-    };
-  }
-
-  static write(
-    state: PoolState,
-    index: number,
-    blockTimestamp: bigint,
-    tick: bigint,
-    liquidity: bigint,
-    cardinality: number,
-    cardinalityNext: number,
-  ): [number, number] {
-    const last = state.observations[index];
-
-    if (last.blockTimestamp == state.blockTimestamp)
-      return [index, cardinality];
-
-    let indexUpdated = 0;
-    let cardinalityUpdated = 0;
-
-    if (cardinalityNext > cardinality && index == cardinality - 1) {
-      cardinalityUpdated = cardinalityNext;
-    } else {
-      cardinalityUpdated = cardinality;
+    static transform(
+        state: DeepReadonly<PoolState>,
+        last: OracleObservation,
+        blockTimestamp: bigint,
+        tick: bigint,
+        liquidity: bigint,
+    ): OracleObservation {
+        const delta = blockTimestamp - last.blockTimestamp;
+        return {
+            blockTimestamp: state.blockTimestamp,
+            tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
+            secondsPerLiquidityCumulativeX128:
+                last.secondsPerLiquidityCumulativeX128 +
+                (BigInt.asUintN(160, delta) << 128n) /
+                (liquidity > 0n ? liquidity : 1n),
+            initialized: true,
+        };
     }
 
-    indexUpdated = (index + 1) % cardinalityUpdated;
-
-    state.observations[indexUpdated] = Oracle.transform(
-      state,
-      last,
-      blockTimestamp,
-      tick,
-      liquidity,
-    );
-    if (indexUpdated !== index) {
-      delete state.observations[index];
-    }
-    return [indexUpdated, cardinalityUpdated];
-  }
-
-  static lte(time: bigint, a: bigint, b: bigint): boolean {
-    if (a <= time && b <= time) return a <= b;
-
-    const aAdjusted = a > time ? a : a + 2n ** 32n;
-    const bAdjusted = b > time ? b : b + 2n ** 32n;
-    return aAdjusted <= bAdjusted;
-  }
-
-  static binarySearch(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    target: bigint,
-    index: number,
-    cardinality: number,
-  ): OracleObservationCandidates {
-    let l = (index + 1) % cardinality;
-    let r = l + cardinality - 1;
-    let i;
-
-    let beforeOrAt;
-    let atOrAfter;
-    while (true) {
-      i = (l + r) / 2;
-
-      beforeOrAt = state.observations[i % cardinality];
-
-      // we've landed on an uninitialized tick, keep searching higher (more recently)
-      if (!beforeOrAt.initialized) {
-        l = i + 1;
-        continue;
-      }
-
-      atOrAfter = state.observations[(i + 1) % cardinality];
-
-      const targetAtOrAfter = Oracle.lte(
-        time,
-        beforeOrAt.blockTimestamp,
-        target,
-      );
-
-      // check if we've found the answer!
-      if (targetAtOrAfter && Oracle.lte(time, target, atOrAfter.blockTimestamp))
-        break;
-
-      if (!targetAtOrAfter) r = i - 1;
-      else l = i + 1;
-    }
-    return { beforeOrAt, atOrAfter };
-  }
-
-  static getSurroundingObservations(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    target: bigint,
-    tick: bigint,
-    index: number,
-    liquidity: bigint,
-    cardinality: number,
-  ): OracleObservationCandidates {
-    let beforeOrAt = state.observations[index];
-
-    if (Oracle.lte(time, beforeOrAt.blockTimestamp, target)) {
-      if (beforeOrAt.blockTimestamp === target) {
-        return { beforeOrAt, atOrAfter: beforeOrAt };
-      } else {
-        return {
-          beforeOrAt,
-          atOrAfter: Oracle.transform(
+    static write(
+        state: PoolState,
+        index: number,
+        blockTimestamp: bigint,
+        tick: bigint,
+        liquidity: bigint,
+        cardinality: number,
+        cardinalityNext: number,
+    ): [number, number] {
+        const last = state.observations[index];
+
+        if (last.blockTimestamp == state.blockTimestamp)
+            return [index, cardinality];
+
+        let indexUpdated = 0;
+        let cardinalityUpdated = 0;
+
+        if (cardinalityNext > cardinality && index == cardinality - 1) {
+            cardinalityUpdated = cardinalityNext;
+        } else {
+            cardinalityUpdated = cardinality;
+        }
+
+        indexUpdated = (index + 1) % cardinalityUpdated;
+
+        state.observations[indexUpdated] = Oracle.transform(
             state,
-            beforeOrAt,
-            target,
+            last,
+            blockTimestamp,
             tick,
             liquidity,
-          ),
-        };
-      }
+        );
+        if (indexUpdated !== index) {
+            delete state.observations[index];
+        }
+        return [indexUpdated, cardinalityUpdated];
+    }
+
+    static lte(time: bigint, a: bigint, b: bigint): boolean {
+        if (a <= time && b <= time) return a <= b;
+
+        const aAdjusted = a > time ? a : a + 2n ** 32n;
+        const bAdjusted = b > time ? b : b + 2n ** 32n;
+        return aAdjusted <= bAdjusted;
+    }
+
+    static binarySearch(
+        state: DeepReadonly<PoolState>,
+        time: bigint,
+        target: bigint,
+        index: number,
+        cardinality: number,
+    ): OracleObservationCandidates {
+        let l = (index + 1) % cardinality;
+        let r = l + cardinality - 1;
+        let i;
+
+        let beforeOrAt;
+        let atOrAfter;
+        while (true) {
+            i = (l + r) / 2;
+
+            beforeOrAt = state.observations[i % cardinality];
+
+            // we've landed on an uninitialized tick, keep searching higher (more recently)
+            if (!beforeOrAt.initialized) {
+                l = i + 1;
+                continue;
+            }
+
+            atOrAfter = state.observations[(i + 1) % cardinality];
+
+            const targetAtOrAfter = Oracle.lte(
+                time,
+                beforeOrAt.blockTimestamp,
+                target,
+            );
+
+            // check if we've found the answer!
+            if (targetAtOrAfter && Oracle.lte(time, target, atOrAfter.blockTimestamp))
+                break;
+
+            if (!targetAtOrAfter) r = i - 1;
+            else l = i + 1;
+        }
+        return { beforeOrAt, atOrAfter };
     }
 
-    beforeOrAt = state.observations[(index + 1) % cardinality];
-    if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
-
-    _require(
-      Oracle.lte(time, beforeOrAt.blockTimestamp, target),
-      'OLD',
-      { time, beforeOrAtBlockTimestamp: beforeOrAt.blockTimestamp, target },
-      'Oracle.lte(time, beforeOrAt.blockTimestamp, target)',
-    );
-
-    return Oracle.binarySearch(state, time, target, index, cardinality);
-  }
-
-  static observeSingle(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    secondsAgo: bigint,
-    tick: bigint,
-    index: number,
-    liquidity: bigint,
-    cardinality: number,
-  ): [bigint, bigint] {
-    if (secondsAgo == 0n) {
-      let last = state.observations[index];
-      if (last.blockTimestamp != time)
-        last = Oracle.transform(state, last, time, tick, liquidity);
-      return [last.tickCumulative, last.secondsPerLiquidityCumulativeX128];
+    static getSurroundingObservations(
+        state: DeepReadonly<PoolState>,
+        time: bigint,
+        target: bigint,
+        tick: bigint,
+        index: number,
+        liquidity: bigint,
+        cardinality: number,
+    ): OracleObservationCandidates {
+        let beforeOrAt = state.observations[index];
+
+        if (Oracle.lte(time, beforeOrAt.blockTimestamp, target)) {
+            if (beforeOrAt.blockTimestamp === target) {
+                return { beforeOrAt, atOrAfter: beforeOrAt };
+            } else {
+                return {
+                    beforeOrAt,
+                    atOrAfter: Oracle.transform(
+                        state,
+                        beforeOrAt,
+                        target,
+                        tick,
+                        liquidity,
+                    ),
+                };
+            }
+        }
+
+        beforeOrAt = state.observations[(index + 1) % cardinality];
+        if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
+
+        _require(
+            Oracle.lte(time, beforeOrAt.blockTimestamp, target),
+            'OLD',
+            { time, beforeOrAtBlockTimestamp: beforeOrAt.blockTimestamp, target },
+            'Oracle.lte(time, beforeOrAt.blockTimestamp, target)',
+        );
+
+        return Oracle.binarySearch(state, time, target, index, cardinality);
     }
 
-    const target = time - secondsAgo;
-
-    const { beforeOrAt, atOrAfter } = Oracle.getSurroundingObservations(
-      state,
-      time,
-      target,
-      tick,
-      index,
-      liquidity,
-      cardinality,
-    );
-
-    if (target === beforeOrAt.blockTimestamp) {
-      return [
-        beforeOrAt.tickCumulative,
-        beforeOrAt.secondsPerLiquidityCumulativeX128,
-      ];
-    } else if (target === atOrAfter.blockTimestamp) {
-      return [
-        atOrAfter.tickCumulative,
-        atOrAfter.secondsPerLiquidityCumulativeX128,
-      ];
-    } else {
-      const observationTimeDelta =
-        atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
-      const targetDelta = target - beforeOrAt.blockTimestamp;
-      return [
-        beforeOrAt.tickCumulative +
-          ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) /
-            observationTimeDelta) *
-            targetDelta,
-        beforeOrAt.secondsPerLiquidityCumulativeX128 +
-          BigInt.asUintN(
-            160,
-            (BigInt.asUintN(
-              256,
-              atOrAfter.secondsPerLiquidityCumulativeX128 -
+    static observeSingle(
+        state: DeepReadonly<PoolState>,
+        time: bigint,
+        secondsAgo: bigint,
+        tick: bigint,
+        index: number,
+        liquidity: bigint,
+        cardinality: number,
+    ): [bigint, bigint] {
+        if (secondsAgo == 0n) {
+            let last = state.observations[index];
+            if (last.blockTimestamp != time)
+                last = Oracle.transform(state, last, time, tick, liquidity);
+            return [last.tickCumulative, last.secondsPerLiquidityCumulativeX128];
+        }
+
+        const target = time - secondsAgo;
+
+        const { beforeOrAt, atOrAfter } = Oracle.getSurroundingObservations(
+            state,
+            time,
+            target,
+            tick,
+            index,
+            liquidity,
+            cardinality,
+        );
+
+        if (target === beforeOrAt.blockTimestamp) {
+            return [
+                beforeOrAt.tickCumulative,
                 beforeOrAt.secondsPerLiquidityCumulativeX128,
-            ) *
-              targetDelta) /
-              observationTimeDelta,
-          ),
-      ];
+            ];
+        } else if (target === atOrAfter.blockTimestamp) {
+            return [
+                atOrAfter.tickCumulative,
+                atOrAfter.secondsPerLiquidityCumulativeX128,
+            ];
+        } else {
+            const observationTimeDelta =
+                atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
+            const targetDelta = target - beforeOrAt.blockTimestamp;
+            return [
+                beforeOrAt.tickCumulative +
+                ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) /
+                    observationTimeDelta) *
+                targetDelta,
+                beforeOrAt.secondsPerLiquidityCumulativeX128 +
+                BigInt.asUintN(
+                    160,
+                    (BigInt.asUintN(
+                            256,
+                            atOrAfter.secondsPerLiquidityCumulativeX128 -
+                            beforeOrAt.secondsPerLiquidityCumulativeX128,
+                        ) *
+                        targetDelta) /
+                    observationTimeDelta,
+                ),
+            ];
+        }
     }
-  }
 }

package/src/dex/uniswap-v3/uniswap-v3-events.test.ts

@@ -13,6 +13,7 @@ import { Interface } from '@ethersproject/abi';
 import ERC20ABI from '../../abi/erc20.json';
 import StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
 import { AbiItem } from 'web3-utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './utils';
 
 jest.setTimeout(300 * 1000);
 const dexKey = 'UniswapV3';
@@ -100,6 +101,7 @@ describe('UniswapV3 Event', function () {
               StateMulticallABI as AbiItem[],
               config.stateMulticall,
             ),
+            decodeStateMultiCallResultWithRelativeBitmaps,
             new Interface(ERC20ABI),
             config.factory,
             poolFeeCode,
@@ -155,6 +157,7 @@ describe('UniswapV3 Event', function () {
         StateMulticallABI as AbiItem[],
         config.stateMulticall,
       ),
+      decodeStateMultiCallResultWithRelativeBitmaps,
       new Interface(ERC20ABI),
       _config.factory,
       _feeCode,

package/src/types.ts

@@ -277,6 +277,7 @@ export type Config = {
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
   dexalotAuthToken?: string;
+  smardexSubgraphAuthToken?: string;
   forceRpcFallbackDexs: string[];
 };