@paraswap/dex-lib 4.1.9 → 4.1.10-ekubo

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

@@ -0,0 +1,267 @@
+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 { PoolKey, PoolState } from '../types';
+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';
+
+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

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

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

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

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

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

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