@paraswap/dex-lib 4.1.19-pools.0 → 4.1.19-pools.2

package/src/dex/ekubo/pools/base-pool.ts

@@ -1,267 +0,0 @@
-import { Interface, Result } from '@ethersproject/abi';
-import { DeepReadonly } from 'ts-essentials';
-import { Log, Logger } from '../../../types';
-import { catchParseLogError } from '../../../utils';
-import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
-import { IDexHelper } from '../../../dex-helper/idex-helper';
-import { Contract } from 'ethers';
-import _ from 'lodash';
-import { computeStep, isPriceIncreasing } from './math/swap';
-import {
-  approximateNumberOfTickSpacingsCrossed,
-  FULL_RANGE_TICK_SPACING,
-  MAX_SQRT_RATIO,
-  MIN_SQRT_RATIO,
-  toSqrtRatio,
-} from './math/tick';
-import { floatSqrtRatioToFixed } from './math/price';
-import { PoolState, PoolKey } from './pool-utils';
-
-export interface Quote {
-  consumedAmount: bigint;
-  calculatedAmount: bigint;
-  gasConsumed: number;
-  skipAhead: number;
-}
-
-const BASE_GAS_COST = 75_000;
-const GAS_COST_OF_ONE_INITIALIZED_TICK_CROSSED = 20_000;
-const GAS_COST_OF_ONE_TICK_SPACING_CROSSED = 4_000;
-
-export class BasePool extends StatefulEventSubscriber<PoolState.Object> {
-  public readonly addressesSubscribed: string[];
-
-  constructor(
-    public readonly parentName: string,
-    protected network: number,
-    protected dexHelper: IDexHelper,
-    logger: Logger,
-    private readonly coreIface: Interface,
-    private readonly dataFetcher: Contract,
-    public readonly key: PoolKey,
-    core: Contract,
-  ) {
-    super(parentName, key.string_id, dexHelper, logger);
-
-    this.addressesSubscribed = [core.address];
-  }
-
-  /**
-   * The function is called every time any of the subscribed
-   * addresses release log. The function accepts the current
-   * state, updates the state according to the log, and returns
-   * the updated state.
-   * @param state - Current state of event subscriber
-   * @param log - Log released by one of the subscribed addresses
-   * @returns Updates state of the event subscriber after the log
-   */
-  protected processLog(
-    state: DeepReadonly<PoolState.Object>,
-    log: Readonly<Log>,
-  ): DeepReadonly<PoolState.Object> | null {
-    if (log.topics.length === 0) {
-      return this.handleSwappedEvent(log.data, state);
-    }
-
-    try {
-      const event = this.coreIface.parseLog(log);
-
-      if (event.name === 'PositionUpdated') {
-        return this.handlePositionUpdatedEvent(event.args, state);
-      }
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-    }
-
-    return null;
-  }
-
-  /**
-   * The function generates state using on-chain calls. This
-   * function is called to regenerate state if the event based
-   * system fails to fetch events and the local state is no
-   * more correct.
-   * @param blockNumber - Blocknumber for which the state should
-   * should be generated
-   * @returns state of the event subscriber at blocknumber
-   */
-  async generateState(
-    blockNumber: number,
-  ): Promise<DeepReadonly<PoolState.Object>> {
-    const data = await this.dataFetcher.getQuoteData([this.key.toAbi()], 10, {
-      blockTag: blockNumber,
-    });
-    return PoolState.fromQuoter(
-      data[0],
-      this.key.config.tickSpacing === FULL_RANGE_TICK_SPACING,
-    );
-  }
-
-  handleSwappedEvent(
-    data: string,
-    oldState: DeepReadonly<PoolState.Object>,
-  ): DeepReadonly<PoolState.Object> | null {
-    let n = BigInt(data);
-
-    const poolId = (n >> 512n) & ((1n << 256n) - 1n);
-
-    if (this.key.num_id !== poolId) {
-      return null;
-    }
-
-    // tick: int32 (4 bytes)
-    const tickRaw = n & ((1n << 32n) - 1n);
-    const tickAfter = Number(toSigned(tickRaw, 32));
-    n >>= 32n;
-
-    // sqrtRatio: uint96 (12 bytes)
-    const sqrtRatioAfterCompact = n & ((1n << 96n) - 1n);
-    n >>= 96n;
-
-    const sqrtRatioAfter = floatSqrtRatioToFixed(sqrtRatioAfterCompact);
-
-    // liquidity: uint128 (16 bytes)
-    const liquidityAfter = n & ((1n << 128n) - 1n);
-
-    return PoolState.fromSwappedEvent(
-      oldState,
-      sqrtRatioAfter,
-      liquidityAfter,
-      tickAfter,
-    );
-  }
-
-  handlePositionUpdatedEvent(
-    args: Result,
-    oldState: DeepReadonly<PoolState.Object>,
-  ): DeepReadonly<PoolState.Object> | null {
-    if (this.key.num_id !== BigInt(args.poolId)) {
-      return null;
-    }
-
-    const params = args.params;
-
-    return PoolState.fromPositionUpdatedEvent(
-      oldState,
-      [params.bounds.lower, params.bounds.upper],
-      params.liquidityDelta.toBigInt(),
-    );
-  }
-
-  public quote(amount: bigint, token: bigint, blockNumber: number): Quote {
-    const isToken1 = token === this.key.token1;
-
-    if (!isToken1 && this.key.token0 !== token) {
-      throw new Error('Invalid token');
-    }
-
-    if (amount === 0n) {
-      return {
-        consumedAmount: 0n,
-        calculatedAmount: 0n,
-        gasConsumed: 0,
-        skipAhead: 0,
-      };
-    }
-
-    const isIncreasing = isPriceIncreasing(amount, isToken1);
-
-    let state = this.getState(blockNumber);
-    if (state === null) {
-      throw new Error(
-        `Quote for block number ${blockNumber} requested but state is not recent enough`,
-      );
-    }
-
-    let { sqrtRatio, liquidity, activeTickIndex, sortedTicks } = state;
-
-    const sqrtRatioLimit = isIncreasing ? MAX_SQRT_RATIO : MIN_SQRT_RATIO;
-
-    let calculatedAmount = 0n;
-    let initializedTicksCrossed = 0;
-    let amountRemaining = amount;
-
-    const startingSqrtRatio = sqrtRatio;
-
-    while (amountRemaining !== 0n && sqrtRatio !== sqrtRatioLimit) {
-      const nextInitializedTick =
-        (isIncreasing
-          ? sortedTicks[activeTickIndex === null ? 0 : activeTickIndex + 1]
-          : activeTickIndex === null
-          ? null
-          : sortedTicks[activeTickIndex]) ?? null;
-
-      const nextInitializedTickSqrtRatio = nextInitializedTick
-        ? toSqrtRatio(nextInitializedTick.number)
-        : null;
-
-      const stepSqrtRatioLimit =
-        nextInitializedTickSqrtRatio === null
-          ? sqrtRatioLimit
-          : nextInitializedTickSqrtRatio < sqrtRatioLimit === isIncreasing
-          ? nextInitializedTickSqrtRatio
-          : sqrtRatioLimit;
-
-      const step = computeStep({
-        fee: this.key.config.fee,
-        sqrtRatio,
-        liquidity,
-        isToken1,
-        sqrtRatioLimit: stepSqrtRatioLimit,
-        amount: amountRemaining,
-      });
-
-      amountRemaining -= step.consumedAmount;
-      calculatedAmount += step.calculatedAmount;
-      sqrtRatio = step.sqrtRatioNext;
-
-      // cross the tick if the price moved all the way to the next initialized tick price
-      if (nextInitializedTick && sqrtRatio === nextInitializedTickSqrtRatio) {
-        activeTickIndex = isIncreasing
-          ? activeTickIndex === null
-            ? 0
-            : activeTickIndex + 1
-          : activeTickIndex
-          ? activeTickIndex - 1
-          : null;
-        initializedTicksCrossed++;
-        liquidity += isIncreasing
-          ? nextInitializedTick.liquidityDelta
-          : -nextInitializedTick.liquidityDelta;
-      }
-    }
-
-    const tickSpacingsCrossed = approximateNumberOfTickSpacingsCrossed(
-      startingSqrtRatio,
-      sqrtRatio,
-      this.key.config.tickSpacing,
-    );
-
-    return {
-      consumedAmount: amount - amountRemaining,
-      calculatedAmount,
-      gasConsumed:
-        BASE_GAS_COST +
-        initializedTicksCrossed * GAS_COST_OF_ONE_INITIALIZED_TICK_CROSSED +
-        tickSpacingsCrossed * GAS_COST_OF_ONE_TICK_SPACING_CROSSED,
-      skipAhead:
-        initializedTicksCrossed === 0
-          ? 0
-          : Math.floor(tickSpacingsCrossed / initializedTicksCrossed),
-    };
-  }
-
-  public computeTvl(): [bigint, bigint] | null {
-    const state = this.getStaleState();
-    if (state === null) {
-      return null;
-    }
-
-    return PoolState.computeTvl(state);
-  }
-}
-
-function toSigned(value: bigint, bits: number): bigint {
-  const half = 1n << BigInt(bits - 1);
-  return value >= half ? value - (1n << BigInt(bits)) : value;
-}

package/src/dex/ekubo/pools/math/constants.ts

@@ -1,5 +0,0 @@
-export const MAX_U256 =
-  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
-export const MAX_U128 = 0xffffffffffffffffffffffffffffffffn;
-export const MIN_I256 =
-  -0x8000000000000000000000000000000000000000000000000000000000000000n;

package/src/dex/ekubo/pools/math/delta.test.ts

@@ -1,131 +0,0 @@
-import { amount0Delta, amount1Delta } from './delta';
-import { MAX_SQRT_RATIO, MIN_SQRT_RATIO } from './tick';
-
-describe(amount0Delta, () => {
-  it('price_down', () => {
-    expect(
-      amount0Delta(
-        339942424496442021441932674757011200255n,
-        0x100000000000000000000000000000000n,
-        1000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`1000n`);
-  });
-
-  it('price_down_reverse', () => {
-    expect(
-      amount0Delta(
-        0x100000000000000000000000000000000n,
-        339942424496442021441932674757011200255n,
-        1000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`1000n`);
-  });
-
-  it('price example down', () => {
-    expect(
-      amount0Delta(
-        0x100000000000000000000000000000000n,
-        34028236692093846346337460743176821145n + (1n << 128n),
-        1000000000000000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`90909090909090909n`);
-  });
-  it('price example up', () => {
-    expect(
-      amount0Delta(
-        0x100000000000000000000000000000000n,
-        34028236692093846346337460743176821145n + (1n << 128n),
-        1000000000000000000n,
-        true,
-      ),
-    ).toMatchInlineSnapshot(`90909090909090910n`);
-  });
-});
-
-describe(amount1Delta, () => {
-  it('price_down', () => {
-    expect(
-      amount1Delta(
-        339942424496442021441932674757011200255n,
-        0x100000000000000000000000000000000n,
-        1000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`999n`);
-  });
-  it('price_down_reverse', () => {
-    expect(
-      amount1Delta(
-        0x100000000000000000000000000000000n,
-        339942424496442021441932674757011200255n,
-        1000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`999n`);
-  });
-  it('price_up', () => {
-    expect(
-      amount1Delta(
-        340622989910849312776150758189957120n + (1n << 128n),
-        0x100000000000000000000000000000000n,
-        1000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`1001n`);
-  });
-  it('price_up_reverse', () => {
-    expect(
-      amount1Delta(
-        0x100000000000000000000000000000000n,
-        339942424496442021441932674757011200255n,
-        1000000n,
-        true,
-      ),
-    ).toMatchInlineSnapshot(`1000n`);
-  });
-  it('price_example_down', () => {
-    expect(
-      amount1Delta(
-        0x100000000000000000000000000000000n,
-        309347606291762239512158734028880192232n,
-        1000000000000000000n,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`90909090909090909n`);
-  });
-  it('price_example_up', () => {
-    expect(
-      amount1Delta(
-        0x100000000000000000000000000000000n,
-        309347606291762239512158734028880192232n,
-        1000000000000000000n,
-        true,
-      ),
-    ).toMatchInlineSnapshot(`90909090909090910n`);
-  });
-  it('no overflow half price range', () => {
-    expect(
-      amount1Delta(
-        0x100000000000000000000000000000000n,
-        MAX_SQRT_RATIO,
-        0xffffffffffffffffn,
-        false,
-      ),
-    ).toMatchInlineSnapshot(`340274119756928397675478831271437331477n`);
-  });
-
-  it('should panic', () => {
-    expect(() =>
-      amount1Delta(
-        MIN_SQRT_RATIO,
-        MAX_SQRT_RATIO,
-        0xffffffffffffffffffffffffffffffffn,
-        false,
-      ),
-    ).toThrow('AMOUNT1_DELTA_OVERFLOW_U256');
-  });
-});

package/src/dex/ekubo/pools/math/delta.ts

@@ -1,68 +0,0 @@
-import { MAX_U128, MAX_U256 } from './constants';
-
-export function amount0Delta(
-  sqrtRatioA: bigint,
-  sqrtRatioB: bigint,
-  liquidity: bigint,
-  roundUp: boolean,
-): bigint {
-  if (liquidity === 0n || sqrtRatioA === sqrtRatioB) return 0n;
-
-  const [lower, upper] =
-    sqrtRatioA < sqrtRatioB
-      ? [sqrtRatioA, sqrtRatioB]
-      : [sqrtRatioB, sqrtRatioA];
-
-  const numerator = (liquidity << 128n) * (upper - lower);
-
-  let result0 = numerator / upper;
-  if (roundUp && numerator % upper !== 0n) {
-    result0++;
-  }
-
-  if (result0 > MAX_U256) {
-    throw new Error('AMOUNT0_DELTA_OVERFLOW_U256');
-  }
-  let result = result0 / lower;
-  if (roundUp && result % lower !== 0n) {
-    result++;
-  }
-
-  if (result > MAX_U128) {
-    throw new Error('AMOUNT0_DELTA_OVERFLOW_U128');
-  }
-
-  return result;
-}
-
-const TWO_POW_128 = 0x100000000000000000000000000000000n;
-
-export function amount1Delta(
-  sqrtRatioA: bigint,
-  sqrtRatioB: bigint,
-  liquidity: bigint,
-  roundUp: boolean,
-): bigint {
-  if (liquidity === 0n || sqrtRatioA === sqrtRatioB) return 0n;
-
-  const [lower, upper] =
-    sqrtRatioA < sqrtRatioB
-      ? [sqrtRatioA, sqrtRatioB]
-      : [sqrtRatioB, sqrtRatioA];
-
-  const result = liquidity * (upper - lower);
-
-  if (result > MAX_U256) {
-    throw new Error('AMOUNT1_DELTA_OVERFLOW_U256');
-  }
-
-  if (roundUp && result % TWO_POW_128 !== 0n) {
-    const delta = result / TWO_POW_128 + 1n;
-    if (delta > MAX_U128) {
-      throw new Error('AMOUNT1_DELTA_OVERFLOW_U128');
-    }
-    return delta;
-  } else {
-    return result >> 128n;
-  }
-}

package/src/dex/ekubo/pools/math/price.test.ts

@@ -1,54 +0,0 @@
-import { nextSqrtRatioFromAmount0, nextSqrtRatioFromAmount1 } from './price';
-
-describe(nextSqrtRatioFromAmount0, () => {
-  it('add_price_goes_down', () => {
-    expect(
-      nextSqrtRatioFromAmount0(1n << 128n, 1000000n, 1000n),
-    ).toMatchInlineSnapshot(`339942424496442021441932674757011200256n`);
-  });
-
-  it('exact_out_overflow', () => {
-    expect(
-      nextSqrtRatioFromAmount0(1n << 128n, 1n, -100000000000000n),
-    ).toMatchInlineSnapshot(`null`);
-  });
-
-  it('exact_in_cant_underflow', () => {
-    expect(
-      nextSqrtRatioFromAmount0(1n << 128n, 1n, 100000000000000n),
-    ).toMatchInlineSnapshot(`3402823669209350606397054n`);
-  });
-  it('sub_price_goes_up', () => {
-    expect(
-      nextSqrtRatioFromAmount0(1n << 128n, 100000000000n, -1000n),
-    ).toMatchInlineSnapshot(`340282370323762166700996274441730955874n`);
-  });
-});
-
-describe(nextSqrtRatioFromAmount1, () => {
-  it('add_price_goes_up', () => {
-    expect(
-      nextSqrtRatioFromAmount1(1n << 128n, 1000000n, 1000n),
-    ).toMatchInlineSnapshot(`340622649287859401926837982039199979667n`);
-  });
-
-  it('exact_out_overflow', () => {
-    expect(
-      nextSqrtRatioFromAmount1(1n << 128n, 1n, -100000000000000n),
-    ).toMatchInlineSnapshot(`null`);
-  });
-
-  it('exact_in_cant_underflow', () => {
-    expect(
-      nextSqrtRatioFromAmount1(1n << 128n, 1n, 100000000000000n),
-    ).toMatchInlineSnapshot(
-      `34028236692094186628704381681640284520207431768211456n`,
-    );
-  });
-
-  it('sub_price_goes_down', () => {
-    expect(
-      nextSqrtRatioFromAmount1(1n << 128n, 100000000000n, -1000n),
-    ).toMatchInlineSnapshot(`340282363518114794253989972798022137138n`);
-  });
-});

package/src/dex/ekubo/pools/math/price.ts

@@ -1,129 +0,0 @@
-import { BigNumber } from 'ethers';
-import { MAX_U256 } from './constants';
-import { MAX_SQRT_RATIO, MIN_SQRT_RATIO } from './tick';
-
-const BIT_MASK = 0xc00000000000000000000000n;
-const NOT_BIT_MASK = 0x3fffffffffffffffffffffffn;
-
-export function floatSqrtRatioToFixed(sqrtRatioFloat: bigint): bigint {
-  return (
-    (sqrtRatioFloat & NOT_BIT_MASK) <<
-    (2n + ((sqrtRatioFloat & BIT_MASK) >> 89n))
-  );
-}
-
-const TWO_POW_192 = 2n ** 192n;
-const TWO_POW_160 = 2n ** 160n;
-const TWO_POW_128 = 2n ** 128n;
-const TWO_POW_96 = 2n ** 96n;
-const TWO_POW_95 = 2n ** 95n;
-const TWO_POW_94 = 2n ** 94n;
-
-export function fixedSqrtRatioToFloat(sqrtRatioFixed: bigint): bigint {
-  if (sqrtRatioFixed >= TWO_POW_192) {
-    throw new Error('Out of bounds');
-  } else if (sqrtRatioFixed >= TWO_POW_160) {
-    return (sqrtRatioFixed >> 98n) + BIT_MASK;
-  } else if (sqrtRatioFixed >= TWO_POW_128) {
-    return (sqrtRatioFixed >> 66n) + TWO_POW_95;
-  } else if (sqrtRatioFixed >= TWO_POW_96) {
-    return (sqrtRatioFixed >> 34n) + TWO_POW_94;
-  } else {
-    return sqrtRatioFixed >> 2n;
-  }
-}
-
-export const MAX_SQRT_RATIO_FLOAT = BigNumber.from(
-  fixedSqrtRatioToFloat(MAX_SQRT_RATIO),
-);
-export const MIN_SQRT_RATIO_FLOAT = BigNumber.from(
-  fixedSqrtRatioToFloat(MIN_SQRT_RATIO),
-);
-
-export function nextSqrtRatioFromAmount0(
-  sqrtRatio: bigint,
-  liquidity: bigint,
-  amount0: bigint,
-): bigint | null {
-  if (amount0 === 0n) return sqrtRatio;
-
-  if (liquidity === 0n) throw new Error('NO_LIQUIDITY');
-
-  const numerator1 = liquidity << 128n;
-
-  // because quotient is rounded down, this price movement is also rounded towards sqrt_ratio
-  if (amount0 < 0n) {
-    const product = amount0 * -1n * sqrtRatio;
-
-    if (product >= MAX_U256) {
-      return null;
-    }
-
-    const denominator = numerator1 - product;
-
-    if (denominator < 0n) {
-      return null;
-    }
-
-    const num = numerator1 * sqrtRatio;
-
-    const result = num / denominator + (num % denominator === 0n ? 0n : 1n);
-
-    if (result > MAX_U256) {
-      return null;
-    }
-
-    return result;
-  } else {
-    const denomP1 = numerator1 / sqrtRatio;
-
-    const denom = denomP1 + amount0;
-    const quotient = numerator1 / denom;
-    const remainder = numerator1 % denom;
-
-    if (remainder === 0n) return quotient;
-    const sum = quotient + 1n;
-    if (sum > MAX_U256) return null;
-    return sum;
-  }
-}
-
-export function nextSqrtRatioFromAmount1(
-  sqrtRatio: bigint,
-  liquidity: bigint,
-  amount1: bigint,
-): bigint | null {
-  if (amount1 === 0n) return sqrtRatio;
-
-  if (liquidity === 0n) throw new Error('NO_LIQUIDITY');
-
-  const amountShifted = amount1 << 128n;
-  const quotient = amountShifted / liquidity;
-  const remainder = amountShifted % liquidity;
-
-  // because quotient is rounded down, this price movement is also rounded towards sqrt_ratio
-  if (amount1 < 0n) {
-    // adding amount1, taking out amount0
-    const res = sqrtRatio + quotient;
-    if (res < 0n) {
-      return null;
-    }
-    if (remainder === 0n) {
-      return res;
-    } else {
-      if (res != 0n) {
-        return res - 1n;
-      } else {
-        return null;
-      }
-    }
-  } else {
-    // adding amount1, taking out amount0, price goes up
-    const res = sqrtRatio + quotient;
-    if (res > MAX_U256) {
-      return null;
-    } else {
-      return res;
-    }
-  }
-}