@paraswap/dex-lib 4.1.9 → 4.1.10-ekubo

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

@@ -0,0 +1,215 @@
+import {
+  amountBeforeFee,
+  computeFee,
+  computeStep,
+  isPriceIncreasing,
+} from './swap';
+import { MAX_SQRT_RATIO, MIN_SQRT_RATIO } from './tick';
+
+describe(isPriceIncreasing, () => {
+  it('many cases', () => {
+    expect(isPriceIncreasing(0n, false)).toBe(false);
+    expect(isPriceIncreasing(1n, false)).toBe(false);
+    expect(isPriceIncreasing(-1n, false)).toBe(true);
+    expect(isPriceIncreasing(0n, true)).toBe(true);
+    expect(isPriceIncreasing(1n, true)).toBe(true);
+    expect(isPriceIncreasing(-1n, true)).toBe(false);
+  });
+});
+
+describe(amountBeforeFee, () => {
+  it('rounds up', () => {
+    expect(amountBeforeFee(105n, (1n << 64n) / 100n)).toMatchInlineSnapshot(
+      `107n`,
+    );
+  });
+});
+
+describe(computeFee, () => {
+  it('rounds up', () => {
+    expect(computeFee(105n, (1n << 64n) / 100n)).toMatchInlineSnapshot(`2n`);
+  });
+  it('rounds evenly', () => {
+    expect(computeFee(100n, (1n << 64n) / 100n)).toMatchInlineSnapshot(`1n`);
+  });
+});
+
+describe(computeStep, () => {
+  it('zero_amount_token0', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: 0n,
+        amount: 0n,
+        isToken1: false,
+        fee: 0n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 0n,
+  "consumedAmount": 0n,
+  "feeAmount": 0n,
+  "sqrtRatioNext": 340282366920938463463374607431768211456n,
+}
+`);
+  });
+  it('zero_amount_token1', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: 0n,
+        amount: 0n,
+        isToken1: true,
+        fee: 0n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 0n,
+  "consumedAmount": 0n,
+  "feeAmount": 0n,
+  "sqrtRatioNext": 340282366920938463463374607431768211456n,
+}
+`);
+  });
+  it('swap_ratio_equal_limit_token1', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: 0x100000000000000000000000000000000n,
+        amount: 10000n,
+        isToken1: true,
+        fee: 0n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 0n,
+  "consumedAmount": 0n,
+  "feeAmount": 0n,
+  "sqrtRatioNext": 340282366920938463463374607431768211456n,
+}
+`);
+  });
+
+  it('max limit token0 input', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: MIN_SQRT_RATIO,
+        amount: 10000n,
+        isToken1: false,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 4761n,
+  "consumedAmount": 10000n,
+  "feeAmount": 5000n,
+  "sqrtRatioNext": 324078444686608060441309149935017344244n,
+}
+`);
+  });
+
+  it('max limit token1 input', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: MAX_SQRT_RATIO,
+        amount: 10000n,
+        isToken1: true,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 4761n,
+  "consumedAmount": 10000n,
+  "feeAmount": 5000n,
+  "sqrtRatioNext": 357296485266985386636543337803356622028n,
+}
+`);
+  });
+
+  it('max limit token0 output', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: MAX_SQRT_RATIO,
+        amount: -10000n,
+        isToken1: false,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 22224n,
+  "consumedAmount": -10000n,
+  "feeAmount": 11112n,
+  "sqrtRatioNext": 378091518801042737181527341590853568285n,
+}
+`);
+  });
+
+  it('max limit token1 output', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: MIN_SQRT_RATIO,
+        amount: -10000n,
+        isToken1: true,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 22224n,
+  "consumedAmount": -10000n,
+  "feeAmount": 11112n,
+  "sqrtRatioNext": 306254130228844617117037146688591390310n,
+}
+`);
+  });
+
+  it('limited token0 output', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: 359186942860990600322450974511310889870n,
+        amount: -10000n,
+        isToken1: false,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 11112n,
+  "consumedAmount": -5263n,
+  "feeAmount": 5556n,
+  "sqrtRatioNext": 359186942860990600322450974511310889870n,
+}
+`);
+  });
+
+  it('limited token1 output', () => {
+    expect(
+      computeStep({
+        sqrtRatio: 0x100000000000000000000000000000000n,
+        liquidity: 100000n,
+        sqrtRatioLimit: 323268248574891540290205877060179800883n,
+        amount: -10000n,
+        isToken1: true,
+        fee: 1n << 63n,
+      }),
+    ).toMatchInlineSnapshot(`
+{
+  "calculatedAmount": 10528n,
+  "consumedAmount": -5000n,
+  "feeAmount": 5264n,
+  "sqrtRatioNext": 323268248574891540290205877060179800883n,
+}
+`);
+  });
+});

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

@@ -0,0 +1,161 @@
+import { nextSqrtRatioFromAmount0, nextSqrtRatioFromAmount1 } from './price';
+import { amount0Delta, amount1Delta } from './delta';
+import { MAX_U128 } from './constants';
+
+interface SwapResult {
+  consumedAmount: bigint;
+  calculatedAmount: bigint;
+  sqrtRatioNext: bigint;
+  feeAmount: bigint;
+}
+
+export function isPriceIncreasing(amount: bigint, isToken1: boolean): boolean {
+  return amount < 0n !== isToken1;
+}
+
+function noOp(sqrtRatioNext: bigint): SwapResult {
+  return {
+    consumedAmount: 0n,
+    calculatedAmount: 0n,
+    sqrtRatioNext,
+    feeAmount: 0n,
+  };
+}
+
+export function amountBeforeFee(amount: bigint, fee: bigint): bigint {
+  if (fee === 0n) return amount;
+  const num = amount << 64n;
+  const denom = (1n << 64n) - fee;
+  const val = num / denom;
+  const result = val + (num % denom !== 0n ? 1n : 0n);
+  if (result > MAX_U128) throw new Error('AMOUNT_BEFORE_FEE_OVERFLOW');
+  return result;
+}
+
+export function computeFee(amount: bigint, fee: bigint) {
+  const num = amount * fee;
+  const denom = 2n ** 64n;
+  if (num % denom !== 0n) {
+    return num / denom + 1n;
+  } else {
+    return num / denom;
+  }
+}
+
+export function computeStep({
+  sqrtRatio,
+  liquidity,
+  sqrtRatioLimit,
+  amount,
+  isToken1,
+  fee,
+}: {
+  sqrtRatio: bigint;
+  liquidity: bigint;
+  sqrtRatioLimit: bigint;
+  amount: bigint;
+  isToken1: boolean;
+  fee: bigint;
+}): SwapResult {
+  if (amount === 0n || sqrtRatio === sqrtRatioLimit) {
+    return noOp(sqrtRatio);
+  }
+
+  const increasing = isPriceIncreasing(amount, isToken1);
+
+  if (sqrtRatioLimit < sqrtRatio === increasing) {
+    throw new Error('computeStep: wrong direction');
+  }
+
+  if (liquidity === 0n) {
+    return noOp(sqrtRatioLimit);
+  }
+
+  let priceImpactAmount: bigint;
+  if (amount < 0n) {
+    priceImpactAmount = amount;
+  } else {
+    priceImpactAmount = amount - computeFee(amount, fee);
+  }
+
+  let sqrtRatioNextFromAmount: bigint | null;
+  if (isToken1) {
+    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount1(
+      sqrtRatio,
+      liquidity,
+      priceImpactAmount,
+    );
+  } else {
+    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount0(
+      sqrtRatio,
+      liquidity,
+      priceImpactAmount,
+    );
+  }
+
+  if (
+    sqrtRatioNextFromAmount === null ||
+    sqrtRatioNextFromAmount > sqrtRatioLimit === increasing
+  ) {
+    const [specifiedAmountDelta, calculatedAmountDelta]: [bigint, bigint] =
+      isToken1
+        ? [
+            amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) *
+              (amount < 0n ? -1n : 1n),
+            amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n),
+          ]
+        : [
+            amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) *
+              (amount < 0n ? -1n : 1n),
+            amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n),
+          ];
+
+    if (amount < 0n) {
+      const beforeFee = amountBeforeFee(calculatedAmountDelta, fee);
+      return {
+        consumedAmount: specifiedAmountDelta,
+        calculatedAmount: beforeFee,
+        feeAmount: beforeFee - calculatedAmountDelta,
+        sqrtRatioNext: sqrtRatioLimit,
+      };
+    } else {
+      const beforeFee = amountBeforeFee(specifiedAmountDelta, fee);
+      return {
+        consumedAmount: beforeFee,
+        calculatedAmount: calculatedAmountDelta,
+        feeAmount: beforeFee - specifiedAmountDelta,
+        sqrtRatioNext: sqrtRatioLimit,
+      };
+    }
+  }
+
+  if (sqrtRatioNextFromAmount === sqrtRatio) {
+    return {
+      consumedAmount: amount,
+      calculatedAmount: 0n,
+      feeAmount: amount,
+      sqrtRatioNext: sqrtRatio,
+    };
+  }
+
+  const calculatedAmountExcludingFee = isToken1
+    ? amount0Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n)
+    : amount1Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n);
+
+  if (amount < 0n) {
+    const includingFee = amountBeforeFee(calculatedAmountExcludingFee, fee);
+    return {
+      consumedAmount: amount,
+      calculatedAmount: includingFee,
+      sqrtRatioNext: sqrtRatioNextFromAmount,
+      feeAmount: includingFee - calculatedAmountExcludingFee,
+    };
+  } else {
+    return {
+      consumedAmount: amount,
+      calculatedAmount: calculatedAmountExcludingFee,
+      sqrtRatioNext: sqrtRatioNextFromAmount,
+      feeAmount: amount - priceImpactAmount,
+    };
+  }
+}

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

@@ -0,0 +1,72 @@
+import {
+  approximateNumberOfTickSpacingsCrossed,
+  MAX_SQRT_RATIO,
+  MAX_TICK,
+  MIN_SQRT_RATIO,
+  MIN_TICK,
+  toSqrtRatio,
+} from './tick';
+
+describe(toSqrtRatio, () => {
+  it('min tick', () => {
+    expect(toSqrtRatio(MIN_TICK)).toEqual(MIN_SQRT_RATIO);
+  });
+  it('max tick', () => {
+    expect(toSqrtRatio(MAX_TICK)).toEqual(MAX_SQRT_RATIO);
+  });
+  it('zero', () => {
+    expect(toSqrtRatio(0)).toEqual(1n << 128n);
+  });
+
+  it('snapshots', () => {
+    expect(toSqrtRatio(1e6)).toMatchInlineSnapshot(
+      `561030636129153856592777659729523183729n`,
+    );
+    expect(toSqrtRatio(1e7)).toMatchInlineSnapshot(
+      `50502254805927926084427918474025309948677n`,
+    );
+    expect(toSqrtRatio(-1e6)).toMatchInlineSnapshot(
+      `206391740095027370700312310531588921767n`,
+    );
+    expect(toSqrtRatio(-1e7)).toMatchInlineSnapshot(
+      `2292810285051363400276741638672651165n`,
+    );
+  });
+});
+
+describe(approximateNumberOfTickSpacingsCrossed, () => {
+  it('same price', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(1n << 128n, 1n << 128n, 1),
+    ).toEqual(0);
+  });
+  it('price doubling 1 tick spacing', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(1n << 128n, 1n << 129n, 1),
+    ).toMatchInlineSnapshot(`5415`);
+  });
+  it('price doubling 1000 tick spacing', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(1n << 128n, 1n << 129n, 1000),
+    ).toMatchInlineSnapshot(`5`);
+  });
+  it('max to min', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(MAX_SQRT_RATIO, MIN_SQRT_RATIO, 1),
+    ).toMatchInlineSnapshot(`693146`);
+  });
+  it('min to max', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(MIN_SQRT_RATIO, MAX_SQRT_RATIO, 1),
+    ).toMatchInlineSnapshot(`693146`);
+  });
+  it('min to max 1k tick spacing', () => {
+    expect(
+      approximateNumberOfTickSpacingsCrossed(
+        MIN_SQRT_RATIO,
+        MAX_SQRT_RATIO,
+        1000,
+      ),
+    ).toMatchInlineSnapshot(`693`);
+  });
+});

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

@@ -0,0 +1,120 @@
+import { MAX_U256 } from './constants';
+
+export const MIN_TICK = -88722835;
+export const MAX_TICK = 88722835;
+export const MAX_SQRT_RATIO: bigint =
+  6276949602062853172742588666638147158083741740262337144812n;
+export const MIN_SQRT_RATIO: bigint = 18447191164202170526n;
+export const FULL_RANGE_TICK_SPACING = 0;
+
+export function toSqrtRatio(tick: number): bigint {
+  if (tick < MIN_TICK || tick > MAX_TICK)
+    throw new Error(`Invalid tick: ${tick}`);
+  let sign = tick < 0;
+  tick = Math.abs(tick);
+  let ratio = 0x100000000000000000000000000000000n;
+  if ((tick & 0x1) != 0) {
+    ratio = 0xfffff79c8499329c7cbb2510d893283bn;
+  }
+  if ((tick & 0x2) != 0) {
+    ratio = (ratio * 0xffffef390978c398134b4ff3764fe410n) >> 128n;
+  }
+  if ((tick & 0x4) != 0) {
+    ratio = (ratio * 0xffffde72140b00a354bd3dc828e976c9n) >> 128n;
+  }
+  if ((tick & 0x8) != 0) {
+    ratio = (ratio * 0xffffbce42c7be6c998ad6318193c0b18n) >> 128n;
+  }
+  if ((tick & 0x10) != 0) {
+    ratio = (ratio * 0xffff79c86a8f6150a32d9778eceef97cn) >> 128n;
+  }
+  if ((tick & 0x20) != 0) {
+    ratio = (ratio * 0xfffef3911b7cff24ba1b3dbb5f8f5974n) >> 128n;
+  }
+  if ((tick & 0x40) != 0) {
+    ratio = (ratio * 0xfffde72350725cc4ea8feece3b5f13c8n) >> 128n;
+  }
+  if ((tick & 0x80) != 0) {
+    ratio = (ratio * 0xfffbce4b06c196e9247ac87695d53c60n) >> 128n;
+  }
+  if ((tick & 0x100) != 0) {
+    ratio = (ratio * 0xfff79ca7a4d1bf1ee8556cea23cdbaa5n) >> 128n;
+  }
+  if ((tick & 0x200) != 0) {
+    ratio = (ratio * 0xffef3995a5b6a6267530f207142a5764n) >> 128n;
+  }
+  if ((tick & 0x400) != 0) {
+    ratio = (ratio * 0xffde7444b28145508125d10077ba83b8n) >> 128n;
+  }
+  if ((tick & 0x800) != 0) {
+    ratio = (ratio * 0xffbceceeb791747f10df216f2e53ec57n) >> 128n;
+  }
+  if ((tick & 0x1000) != 0) {
+    ratio = (ratio * 0xff79eb706b9a64c6431d76e63531e929n) >> 128n;
+  }
+  if ((tick & 0x2000) != 0) {
+    ratio = (ratio * 0xfef41d1a5f2ae3a20676bec6f7f9459an) >> 128n;
+  }
+  if ((tick & 0x4000) != 0) {
+    ratio = (ratio * 0xfde95287d26d81bea159c37073122c73n) >> 128n;
+  }
+  if ((tick & 0x8000) != 0) {
+    ratio = (ratio * 0xfbd701c7cbc4c8a6bb81efd232d1e4e7n) >> 128n;
+  }
+  if ((tick & 0x10000) != 0) {
+    ratio = (ratio * 0xf7bf5211c72f5185f372aeb1d48f937en) >> 128n;
+  }
+  if ((tick & 0x20000) != 0) {
+    ratio = (ratio * 0xefc2bf59df33ecc28125cf78ec4f167fn) >> 128n;
+  }
+  if ((tick & 0x40000) != 0) {
+    ratio = (ratio * 0xe08d35706200796273f0b3a981d90cfdn) >> 128n;
+  }
+  if ((tick & 0x80000) != 0) {
+    ratio = (ratio * 0xc4f76b68947482dc198a48a54348c4edn) >> 128n;
+  }
+  if ((tick & 0x100000) != 0) {
+    ratio = (ratio * 0x978bcb9894317807e5fa4498eee7c0fan) >> 128n;
+  }
+  if ((tick & 0x200000) != 0) {
+    ratio = (ratio * 0x59b63684b86e9f486ec54727371ba6can) >> 128n;
+  }
+  if ((tick & 0x400000) != 0) {
+    ratio = (ratio * 0x1f703399d88f6aa83a28b22d4a1f56e3n) >> 128n;
+  }
+  if ((tick & 0x800000) != 0) {
+    ratio = (ratio * 0x3dc5dac7376e20fc8679758d1bcdcfcn) >> 128n;
+  }
+  if ((tick & 0x1000000) != 0) {
+    ratio = (ratio * 0xee7e32d61fdb0a5e622b820f681d0n) >> 128n;
+  }
+  if ((tick & 0x2000000) != 0) {
+    ratio = (ratio * 0xde2ee4bc381afa7089aa84bb66n) >> 128n;
+  }
+  if ((tick & 0x4000000) != 0) {
+    ratio = (ratio * 0xc0d55d4d7152c25fb139n) >> 128n;
+  }
+
+  if (tick > 0 && !sign) {
+    ratio = MAX_U256 / ratio;
+  }
+
+  return ratio;
+}
+
+const logBase = Math.log(1.0000005);
+
+export function approximateNumberOfTickSpacingsCrossed(
+  sqrtRatioStart: bigint,
+  sqrtRatioEnd: bigint,
+  tickSpacing: number,
+): number {
+  if (tickSpacing === FULL_RANGE_TICK_SPACING) {
+    return 0;
+  }
+
+  const logPriceDiff =
+    Math.log(Number(sqrtRatioEnd) / Number(sqrtRatioStart)) / logBase;
+
+  return Math.floor(Math.abs(logPriceDiff / (tickSpacing * 256)));
+}

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

@@ -0,0 +1,46 @@
+import { Contract } from 'ethers';
+import { IDexHelper } from '../../../dex-helper';
+import { Logger } from '../../../types';
+import { BasePool, Quote } from './base-pool';
+import { PoolKey } from '../types';
+import { Interface } from '@ethersproject/abi';
+
+const GAS_COST_OF_UPDATING_ORACLE_SNAPSHOT = 15_000;
+
+export class OraclePool extends BasePool {
+  public constructor(
+    parentName: string,
+    network: number,
+    dexHelper: IDexHelper,
+    logger: Logger,
+    coreIface: Interface,
+    dataFetcher: Contract,
+    key: PoolKey,
+    core: Contract,
+  ) {
+    super(
+      parentName,
+      network,
+      dexHelper,
+      logger,
+      coreIface,
+      dataFetcher,
+      key,
+      core,
+    );
+  }
+
+  public override quote(
+    amount: bigint,
+    token: bigint,
+    blockNumber: number,
+  ): Quote {
+    let baseQuote = super.quote(amount, token, blockNumber);
+
+    if (baseQuote.gasConsumed > 0n) {
+      baseQuote.gasConsumed += GAS_COST_OF_UPDATING_ORACLE_SNAPSHOT;
+    }
+
+    return baseQuote;
+  }
+}