@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-core-main/test/shared/checkObservationEquals.ts

@@ -0,0 +1,38 @@
+import { BigNumber, BigNumberish } from 'ethers'
+import { expect } from './expect'
+
+// helper function because we cannot do a simple deep equals with the
+// observation result object returned from ethers because it extends array
+export default function checkObservationEquals(
+  {
+    tickCumulative,
+    blockTimestamp,
+    initialized,
+    secondsPerLiquidityCumulativeX128,
+  }: {
+    tickCumulative: BigNumber
+    secondsPerLiquidityCumulativeX128: BigNumber
+    initialized: boolean
+    blockTimestamp: number
+  },
+  expected: {
+    tickCumulative: BigNumberish
+    secondsPerLiquidityCumulativeX128: BigNumberish
+    initialized: boolean
+    blockTimestamp: number
+  }
+) {
+  expect(
+    {
+      initialized,
+      blockTimestamp,
+      tickCumulative: tickCumulative.toString(),
+      secondsPerLiquidityCumulativeX128: secondsPerLiquidityCumulativeX128.toString(),
+    },
+    `observation is equivalent`
+  ).to.deep.eq({
+    ...expected,
+    tickCumulative: expected.tickCumulative.toString(),
+    secondsPerLiquidityCumulativeX128: expected.secondsPerLiquidityCumulativeX128.toString(),
+  })
+}

package/lib/v3-core-main/test/shared/expect.ts

@@ -0,0 +1,8 @@
+import { expect, use } from 'chai'
+import { solidity } from 'ethereum-waffle'
+import { jestSnapshotPlugin } from 'mocha-chai-jest-snapshot'
+
+use(solidity)
+use(jestSnapshotPlugin())
+
+export { expect }

package/lib/v3-core-main/test/shared/fixtures.ts

@@ -0,0 +1,92 @@
+import { BigNumber } from 'ethers'
+import { ethers } from 'hardhat'
+import { MockTimeUniswapV3Pool } from '../../typechain/MockTimeUniswapV3Pool'
+import { TestERC20 } from '../../typechain/TestERC20'
+import { UniswapV3Factory } from '../../typechain/UniswapV3Factory'
+import { TestUniswapV3Callee } from '../../typechain/TestUniswapV3Callee'
+import { TestUniswapV3Router } from '../../typechain/TestUniswapV3Router'
+import { MockTimeUniswapV3PoolDeployer } from '../../typechain/MockTimeUniswapV3PoolDeployer'
+
+import { Fixture } from 'ethereum-waffle'
+
+interface FactoryFixture {
+  factory: UniswapV3Factory
+}
+
+async function factoryFixture(): Promise<FactoryFixture> {
+  const factoryFactory = await ethers.getContractFactory('UniswapV3Factory')
+  const factory = (await factoryFactory.deploy()) as UniswapV3Factory
+  return { factory }
+}
+
+interface TokensFixture {
+  token0: TestERC20
+  token1: TestERC20
+  token2: TestERC20
+}
+
+async function tokensFixture(): Promise<TokensFixture> {
+  const tokenFactory = await ethers.getContractFactory('TestERC20')
+  const tokenA = (await tokenFactory.deploy(BigNumber.from(2).pow(255))) as TestERC20
+  const tokenB = (await tokenFactory.deploy(BigNumber.from(2).pow(255))) as TestERC20
+  const tokenC = (await tokenFactory.deploy(BigNumber.from(2).pow(255))) as TestERC20
+
+  const [token0, token1, token2] = [tokenA, tokenB, tokenC].sort((tokenA, tokenB) =>
+    tokenA.address.toLowerCase() < tokenB.address.toLowerCase() ? -1 : 1
+  )
+
+  return { token0, token1, token2 }
+}
+
+type TokensAndFactoryFixture = FactoryFixture & TokensFixture
+
+interface PoolFixture extends TokensAndFactoryFixture {
+  swapTargetCallee: TestUniswapV3Callee
+  swapTargetRouter: TestUniswapV3Router
+  createPool(
+    fee: number,
+    tickSpacing: number,
+    firstToken?: TestERC20,
+    secondToken?: TestERC20
+  ): Promise<MockTimeUniswapV3Pool>
+}
+
+// Monday, October 5, 2020 9:00:00 AM GMT-05:00
+export const TEST_POOL_START_TIME = 1601906400
+
+export const poolFixture: Fixture<PoolFixture> = async function (): Promise<PoolFixture> {
+  const { factory } = await factoryFixture()
+  const { token0, token1, token2 } = await tokensFixture()
+
+  const MockTimeUniswapV3PoolDeployerFactory = await ethers.getContractFactory('MockTimeUniswapV3PoolDeployer')
+  const MockTimeUniswapV3PoolFactory = await ethers.getContractFactory('MockTimeUniswapV3Pool')
+
+  const calleeContractFactory = await ethers.getContractFactory('TestUniswapV3Callee')
+  const routerContractFactory = await ethers.getContractFactory('TestUniswapV3Router')
+
+  const swapTargetCallee = (await calleeContractFactory.deploy()) as TestUniswapV3Callee
+  const swapTargetRouter = (await routerContractFactory.deploy()) as TestUniswapV3Router
+
+  return {
+    token0,
+    token1,
+    token2,
+    factory,
+    swapTargetCallee,
+    swapTargetRouter,
+    createPool: async (fee, tickSpacing, firstToken = token0, secondToken = token1) => {
+      const mockTimePoolDeployer = (await MockTimeUniswapV3PoolDeployerFactory.deploy()) as MockTimeUniswapV3PoolDeployer
+      const tx = await mockTimePoolDeployer.deploy(
+        factory.address,
+        firstToken.address,
+        secondToken.address,
+        fee,
+        tickSpacing
+      )
+
+      const receipt = await tx.wait()
+      const poolAddress = receipt.events?.[0].args?.pool as string
+      return MockTimeUniswapV3PoolFactory.attach(poolAddress) as MockTimeUniswapV3Pool
+    },
+  }
+}

package/lib/v3-core-main/test/shared/format.ts

@@ -0,0 +1,10 @@
+import { Decimal } from 'decimal.js'
+import { BigNumberish } from 'ethers'
+
+export function formatTokenAmount(num: BigNumberish): string {
+  return new Decimal(num.toString()).dividedBy(new Decimal(10).pow(18)).toPrecision(5)
+}
+
+export function formatPrice(price: BigNumberish): string {
+  return new Decimal(price.toString()).dividedBy(new Decimal(2).pow(96)).pow(2).toPrecision(5)
+}

package/lib/v3-core-main/test/shared/snapshotGasCost.ts

@@ -0,0 +1,27 @@
+import { TransactionReceipt, TransactionResponse } from '@ethersproject/abstract-provider'
+import { expect } from './expect'
+import { Contract, BigNumber, ContractTransaction } from 'ethers'
+
+export default async function snapshotGasCost(
+  x:
+    | TransactionResponse
+    | Promise<TransactionResponse>
+    | ContractTransaction
+    | Promise<ContractTransaction>
+    | TransactionReceipt
+    | Promise<BigNumber>
+    | BigNumber
+    | Contract
+    | Promise<Contract>
+): Promise<void> {
+  const resolved = await x
+  if ('deployTransaction' in resolved) {
+    const receipt = await resolved.deployTransaction.wait()
+    expect(receipt.gasUsed.toNumber()).toMatchSnapshot()
+  } else if ('wait' in resolved) {
+    const waited = await resolved.wait()
+    expect(waited.gasUsed.toNumber()).toMatchSnapshot()
+  } else if (BigNumber.isBigNumber(resolved)) {
+    expect(resolved.toNumber()).toMatchSnapshot()
+  }
+}

package/lib/v3-core-main/test/shared/utilities.ts

@@ -0,0 +1,258 @@
+import bn from 'bignumber.js'
+import { BigNumber, BigNumberish, constants, Contract, ContractTransaction, utils, Wallet } from 'ethers'
+import { TestUniswapV3Callee } from '../../typechain/TestUniswapV3Callee'
+import { TestUniswapV3Router } from '../../typechain/TestUniswapV3Router'
+import { MockTimeUniswapV3Pool } from '../../typechain/MockTimeUniswapV3Pool'
+import { TestERC20 } from '../../typechain/TestERC20'
+
+export const MaxUint128 = BigNumber.from(2).pow(128).sub(1)
+
+export const getMinTick = (tickSpacing: number) => Math.ceil(-887272 / tickSpacing) * tickSpacing
+export const getMaxTick = (tickSpacing: number) => Math.floor(887272 / tickSpacing) * tickSpacing
+export const getMaxLiquidityPerTick = (tickSpacing: number) =>
+  BigNumber.from(2)
+    .pow(128)
+    .sub(1)
+    .div((getMaxTick(tickSpacing) - getMinTick(tickSpacing)) / tickSpacing + 1)
+
+export const MIN_SQRT_RATIO = BigNumber.from('4295128739')
+export const MAX_SQRT_RATIO = BigNumber.from('1461446703485210103287273052203988822378723970342')
+
+export enum FeeAmount {
+  LOW = 500,
+  MEDIUM = 3000,
+  HIGH = 10000,
+}
+
+export const TICK_SPACINGS: { [amount in FeeAmount]: number } = {
+  [FeeAmount.LOW]: 10,
+  [FeeAmount.MEDIUM]: 60,
+  [FeeAmount.HIGH]: 200,
+}
+
+export function expandTo18Decimals(n: number): BigNumber {
+  return BigNumber.from(n).mul(BigNumber.from(10).pow(18))
+}
+
+export function getCreate2Address(
+  factoryAddress: string,
+  [tokenA, tokenB]: [string, string],
+  fee: number,
+  bytecode: string
+): string {
+  const [token0, token1] = tokenA.toLowerCase() < tokenB.toLowerCase() ? [tokenA, tokenB] : [tokenB, tokenA]
+  const constructorArgumentsEncoded = utils.defaultAbiCoder.encode(
+    ['address', 'address', 'uint24'],
+    [token0, token1, fee]
+  )
+  const create2Inputs = [
+    '0xff',
+    factoryAddress,
+    // salt
+    utils.keccak256(constructorArgumentsEncoded),
+    // init code. bytecode + constructor arguments
+    utils.keccak256(bytecode),
+  ]
+  const sanitizedInputs = `0x${create2Inputs.map((i) => i.slice(2)).join('')}`
+  return utils.getAddress(`0x${utils.keccak256(sanitizedInputs).slice(-40)}`)
+}
+
+bn.config({ EXPONENTIAL_AT: 999999, DECIMAL_PLACES: 40 })
+
+// returns the sqrt price as a 64x96
+export function encodePriceSqrt(reserve1: BigNumberish, reserve0: BigNumberish): BigNumber {
+  return BigNumber.from(
+    new bn(reserve1.toString())
+      .div(reserve0.toString())
+      .sqrt()
+      .multipliedBy(new bn(2).pow(96))
+      .integerValue(3)
+      .toString()
+  )
+}
+
+export function getPositionKey(address: string, lowerTick: number, upperTick: number): string {
+  return utils.keccak256(utils.solidityPack(['address', 'int24', 'int24'], [address, lowerTick, upperTick]))
+}
+
+export type SwapFunction = (
+  amount: BigNumberish,
+  to: Wallet | string,
+  sqrtPriceLimitX96?: BigNumberish
+) => Promise<ContractTransaction>
+export type SwapToPriceFunction = (sqrtPriceX96: BigNumberish, to: Wallet | string) => Promise<ContractTransaction>
+export type FlashFunction = (
+  amount0: BigNumberish,
+  amount1: BigNumberish,
+  to: Wallet | string,
+  pay0?: BigNumberish,
+  pay1?: BigNumberish
+) => Promise<ContractTransaction>
+export type MintFunction = (
+  recipient: string,
+  tickLower: BigNumberish,
+  tickUpper: BigNumberish,
+  liquidity: BigNumberish
+) => Promise<ContractTransaction>
+export interface PoolFunctions {
+  swapToLowerPrice: SwapToPriceFunction
+  swapToHigherPrice: SwapToPriceFunction
+  swapExact0For1: SwapFunction
+  swap0ForExact1: SwapFunction
+  swapExact1For0: SwapFunction
+  swap1ForExact0: SwapFunction
+  flash: FlashFunction
+  mint: MintFunction
+}
+export function createPoolFunctions({
+  swapTarget,
+  token0,
+  token1,
+  pool,
+}: {
+  swapTarget: TestUniswapV3Callee
+  token0: TestERC20
+  token1: TestERC20
+  pool: MockTimeUniswapV3Pool
+}): PoolFunctions {
+  async function swapToSqrtPrice(
+    inputToken: Contract,
+    targetPrice: BigNumberish,
+    to: Wallet | string
+  ): Promise<ContractTransaction> {
+    const method = inputToken === token0 ? swapTarget.swapToLowerSqrtPrice : swapTarget.swapToHigherSqrtPrice
+
+    await inputToken.approve(swapTarget.address, constants.MaxUint256)
+
+    const toAddress = typeof to === 'string' ? to : to.address
+
+    return method(pool.address, targetPrice, toAddress)
+  }
+
+  async function swap(
+    inputToken: Contract,
+    [amountIn, amountOut]: [BigNumberish, BigNumberish],
+    to: Wallet | string,
+    sqrtPriceLimitX96?: BigNumberish
+  ): Promise<ContractTransaction> {
+    const exactInput = amountOut === 0
+
+    const method =
+      inputToken === token0
+        ? exactInput
+          ? swapTarget.swapExact0For1
+          : swapTarget.swap0ForExact1
+        : exactInput
+        ? swapTarget.swapExact1For0
+        : swapTarget.swap1ForExact0
+
+    if (typeof sqrtPriceLimitX96 === 'undefined') {
+      if (inputToken === token0) {
+        sqrtPriceLimitX96 = MIN_SQRT_RATIO.add(1)
+      } else {
+        sqrtPriceLimitX96 = MAX_SQRT_RATIO.sub(1)
+      }
+    }
+    await inputToken.approve(swapTarget.address, constants.MaxUint256)
+
+    const toAddress = typeof to === 'string' ? to : to.address
+
+    return method(pool.address, exactInput ? amountIn : amountOut, toAddress, sqrtPriceLimitX96)
+  }
+
+  const swapToLowerPrice: SwapToPriceFunction = (sqrtPriceX96, to) => {
+    return swapToSqrtPrice(token0, sqrtPriceX96, to)
+  }
+
+  const swapToHigherPrice: SwapToPriceFunction = (sqrtPriceX96, to) => {
+    return swapToSqrtPrice(token1, sqrtPriceX96, to)
+  }
+
+  const swapExact0For1: SwapFunction = (amount, to, sqrtPriceLimitX96) => {
+    return swap(token0, [amount, 0], to, sqrtPriceLimitX96)
+  }
+
+  const swap0ForExact1: SwapFunction = (amount, to, sqrtPriceLimitX96) => {
+    return swap(token0, [0, amount], to, sqrtPriceLimitX96)
+  }
+
+  const swapExact1For0: SwapFunction = (amount, to, sqrtPriceLimitX96) => {
+    return swap(token1, [amount, 0], to, sqrtPriceLimitX96)
+  }
+
+  const swap1ForExact0: SwapFunction = (amount, to, sqrtPriceLimitX96) => {
+    return swap(token1, [0, amount], to, sqrtPriceLimitX96)
+  }
+
+  const mint: MintFunction = async (recipient, tickLower, tickUpper, liquidity) => {
+    await token0.approve(swapTarget.address, constants.MaxUint256)
+    await token1.approve(swapTarget.address, constants.MaxUint256)
+    return swapTarget.mint(pool.address, recipient, tickLower, tickUpper, liquidity)
+  }
+
+  const flash: FlashFunction = async (amount0, amount1, to, pay0?: BigNumberish, pay1?: BigNumberish) => {
+    const fee = await pool.fee()
+    if (typeof pay0 === 'undefined') {
+      pay0 = BigNumber.from(amount0)
+        .mul(fee)
+        .add(1e6 - 1)
+        .div(1e6)
+        .add(amount0)
+    }
+    if (typeof pay1 === 'undefined') {
+      pay1 = BigNumber.from(amount1)
+        .mul(fee)
+        .add(1e6 - 1)
+        .div(1e6)
+        .add(amount1)
+    }
+    return swapTarget.flash(pool.address, typeof to === 'string' ? to : to.address, amount0, amount1, pay0, pay1)
+  }
+
+  return {
+    swapToLowerPrice,
+    swapToHigherPrice,
+    swapExact0For1,
+    swap0ForExact1,
+    swapExact1For0,
+    swap1ForExact0,
+    mint,
+    flash,
+  }
+}
+
+export interface MultiPoolFunctions {
+  swapForExact0Multi: SwapFunction
+  swapForExact1Multi: SwapFunction
+}
+
+export function createMultiPoolFunctions({
+  inputToken,
+  swapTarget,
+  poolInput,
+  poolOutput,
+}: {
+  inputToken: TestERC20
+  swapTarget: TestUniswapV3Router
+  poolInput: MockTimeUniswapV3Pool
+  poolOutput: MockTimeUniswapV3Pool
+}): MultiPoolFunctions {
+  async function swapForExact0Multi(amountOut: BigNumberish, to: Wallet | string): Promise<ContractTransaction> {
+    const method = swapTarget.swapForExact0Multi
+    await inputToken.approve(swapTarget.address, constants.MaxUint256)
+    const toAddress = typeof to === 'string' ? to : to.address
+    return method(toAddress, poolInput.address, poolOutput.address, amountOut)
+  }
+
+  async function swapForExact1Multi(amountOut: BigNumberish, to: Wallet | string): Promise<ContractTransaction> {
+    const method = swapTarget.swapForExact1Multi
+    await inputToken.approve(swapTarget.address, constants.MaxUint256)
+    const toAddress = typeof to === 'string' ? to : to.address
+    return method(toAddress, poolInput.address, poolOutput.address, amountOut)
+  }
+
+  return {
+    swapForExact0Multi,
+    swapForExact1Multi,
+  }
+}

package/lib/v3-core-main/test/snapshotCumulativesInside.test.ts

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+
+import { expect } from 'chai';
+import { ethers, waffle } from 'hardhat';
+import { MockTimeUniswapV3Pool } from '../typechain/MockTimeUniswapV3Pool';
+import { TestERC20 } from '../typechain/TestERC20';
+import { UniswapV3Factory } from '../typechain/UniswapV3Factory';
+import { poolFixture, TEST_POOL_START_TIME } from './shared/fixtures';
+import { FeeAmount, TICK_SPACINGS, encodePriceSqrt, getMinTick, getMaxTick } from './shared/utilities';
+
+/**
+ * Test that demonstrates how to initialize the ticks required for
+ * `snapshotCumulativesInside` so that the call does not revert.
+ *
+ * The steps are:
+ *   1. Deploy a pool via the `poolFixture` helper (which also deploys mock ERC20 tokens).
+ *   2. Initialize the pool with a 1:1 price.
+ *   3. Choose a tick spacing (the fixture uses the fee amount to set this).
+ *   4. Mint a position that spans a lower and upper tick that are *initialized* – i.e.
+ *      they are multiples of the pool's `tickSpacing`.
+ *   5. Call `snapshotCumulativesInside` with those ticks and assert that the
+ *      returned values are numbers (BigNumber) and that the call succeeds.
+ */
+
+describe('snapshotCumulativesInside – initialize ticks', function () {
+  let wallet: any;
+  let other: any;
+  let pool: MockTimeUniswapV3Pool;
+  let token0: TestERC20;
+  let token1: TestERC20;
+  let factory: UniswapV3Factory;
+
+  const FEE = FeeAmount.MEDIUM; // 0.3% fee – typical tick spacing = 60
+
+  before(async function () {
+    // grab signers
+    [wallet, other] = await (ethers as any).getSigners();
+    const loadFixture = waffle.createFixtureLoader([wallet, other]);
+    const fixture = await loadFixture(poolFixture);
+    token0 = fixture.token0;
+    token1 = fixture.token1;
+    factory = fixture.factory;
+    // create pool with chosen fee and spacing
+    const createPool = fixture.createPool;
+    pool = await createPool(FEE, TICK_SPACINGS[FEE]);
+    // initialize at price 1:1 (sqrtPriceX96 = 2**96)
+    const sqrtPriceX96 = ethers.BigNumber.from('79228162514264337593543950336'); // 2**96
+    await pool.initialize(sqrtPriceX96);
+  });
+
+  it('should not revert when calling snapshotCumulativesInside on initialized ticks', async function () {
+    // fetch the pool's tick spacing (should be 60 for medium fee)
+    const tickSpacing = await pool.tickSpacing();
+    // pick lower/upper ticks that are multiples of spacing and surround 0
+    const tickLower = -tickSpacing; // e.g., -60
+    const tickUpper = tickSpacing; // e.g., 60
+
+    // mint a position that spans these ticks – this will mark them as initialized
+    const liquidity = ethers.utils.parseUnits('1000', 18);
+    // approve pool to move tokens (required for mint in the fixture's pool implementation)
+    await token0.approve(pool.address, ethers.constants.MaxUint256);
+    await token1.approve(pool.address, ethers.constants.MaxUint256);
+    await pool.mint(wallet.address, tickLower, tickUpper, liquidity, '0x');
+
+    // now snapshotCumulativesInside should succeed
+    const result = await pool.snapshotCumulativesInside(tickLower, tickUpper);
+    console.log('snapshotCumulativesInside result:', result);
+    // sanity checks – the three returned values are big numbers (int56, uint160, uint32)
+    expect(result.tickCumulativeInside).to.be.a('bigint');
+    expect(result.secondsPerLiquidityInsideX128).to.be.a('bigint');
+    expect(result.secondsInside).to.be.a('bigint');
+  });
+});

package/lib/v3-core-main/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "typeRoots": ["./typechain", "./node_modules/@types"],
+    "types": ["@nomiclabs/hardhat-ethers", "@nomiclabs/hardhat-waffle"]
+  },
+  "include": ["./test"],
+  "files": ["./hardhat.config.ts"]
+}