stakewithus / defi-by-example Goto Github PK

const { expect } = require("chai")
const { ethers } = require("hardhat")

const DAI = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
const DAI_WHALE = "0x6FF8E4DB500cBd77d1D181B8908E022E29e0Ec4A"
const USDC_WHALE = "0xc3dcB715eDeb0374E968177A3620c441344c3ED8"
const IWETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
const wethAmount = ethers.utils.parseEther("1")

describe("LiquidityExamples", () => {
  let liquidityExamples
  let accounts
  let dai
  let usdc
  let owner
  let iweth

  before(async () => {
    accounts = await ethers.getSigners()
    owner = accounts[0]
    console.log(`owner address : ${owner.address}`)
    console.log(`account[0] address : ${accounts[0].address}`)

    const LiquidityExamples = await ethers.getContractFactory(
      "LiquidityExamples"
    )
    liquidityExamples = await LiquidityExamples.deploy()
    await liquidityExamples.deployed()

    dai = await ethers.getContractAt("IERC20", DAI)
    usdc = await ethers.getContractAt("IERC20", USDC)
    iweth = await ethers.getContractAt("IWETH", IWETH)

    // Unlock DAI and USDC whales
    await network.provider.request({
      method: "hardhat_impersonateAccount",
      params: [DAI_WHALE],
    })
    await network.provider.request({
      method: "hardhat_impersonateAccount",
      params: [USDC_WHALE],
    })
    // get Signers
    const daiWhale = await ethers.getSigner(DAI_WHALE)
    const usdcWhale = await ethers.getSigner(USDC_WHALE)

    const daiBal = await dai.balanceOf(DAI_WHALE)
    const usdcBal = await usdc.balanceOf(USDC_WHALE)

    // Send DAI and USDC to accounts[0]
    const daiAmount = 10n * 10n ** 18n
    const usdcAmount = 10n * 10n ** 6n

    await dai.connect(daiWhale).transfer(owner.address, daiAmount)
    await usdc.connect(usdcWhale).transfer(owner.address, usdcAmount)

    const daiBalance = await dai.balanceOf(owner.address)
  })

  it("mintNewPosition", async () => {
    const daiAmount = 1n * 10n ** 18n
    const usdcAmount = 1n * 10n ** 6n

    await dai.connect(owner).transfer(liquidityExamples.address, daiAmount)
    await usdc.connect(owner).transfer(liquidityExamples.address, usdcAmount)

    await liquidityExamples.mintNewPosition()

    console.log(
      "DAI balance after add liquidity",
      await dai.balanceOf(accounts[0].address)
    )
    console.log(
      "USDC balance after add liquidity",
      await usdc.balanceOf(accounts[0].address)
    )
  })

  it.skip("increaseLiquidityCurrentRange", async () => {
    const daiAmount = 20n * 10n ** 18n
    const usdcAmount = 20n * 10n ** 6n

    await dai.connect(accounts[0]).approve(liquidityExamples.address, daiAmount)
    await usdc
      .connect(accounts[0])
      .approve(liquidityExamples.address, usdcAmount)

    await liquidityExamples.increaseLiquidityCurrentRange(daiAmount, usdcAmount)
  })

  it("decreaseLiquidity", async () => {
    const tokenId = await liquidityExamples.tokenId()
    const liquidity = await liquidityExamples.getLiquidity(tokenId)

    await liquidityExamples.decreaseLiquidity(liquidity)

    console.log("--- decrease liquidity ---")
    console.log(`liquidity ${liquidity}`)
    console.log(`dai ${await dai.balanceOf(liquidityExamples.address)}`)
    console.log(`usdc ${await usdc.balanceOf(liquidityExamples.address)}`)
  })

  it("collectAllFees", async () => {
    await liquidityExamples.collectAllFees()

    console.log("--- collect fees ---")
    console.log(`dai ${await dai.balanceOf(liquidityExamples.address)}`)
    console.log(`usdc ${await usdc.balanceOf(liquidityExamples.address)}`)
  })
})

function mintPosition(
        address token0,
        address token1,
        uint24 poolFee,
        uint256 amount0,
        uint256 amount1,
        int24 rangeLeft,
        int24 rangeRight) external payable override returns (
            uint256 tokenId,
            uint128 liquidity,
            uint256 actualAmount0,
            uint256 actualAmount1
        )
    {

        // Approve the position manager
        TransferHelper.safeApprove(token0, address(nonfungiblePositionManager), amount0);
        TransferHelper.safeApprove(token1, address(nonfungiblePositionManager), amount1);

        INonfungiblePositionManager.MintParams memory params =
            INonfungiblePositionManager.MintParams({
                token0: token0,
                token1: token1,
                fee: poolFee,
                tickLower: rangeLeft,
                tickUpper: rangeRight,
                amount0Desired: amount0,
                amount1Desired: amount1,
                amount0Min: 0,
                amount1Min: 0,
                recipient: address(this),
                deadline: block.timestamp
            });

        // Note that the pool defined by token0/token1 and fee tier poolFee must already be created and initialized in order to mint
        // THIS TRANSACTION FAILS WITHOUT A REASON STRING
        (tokenId, liquidity, actualAmount0, actualAmount1) = nonfungiblePositionManager.mint(params);

        // Create a deposit
        _createDeposit(msg.sender, tokenId);

        // Remove allowance and refund in both assets.
        if (actualAmount0 < amount0) {
            TransferHelper.safeApprove(token0, address(nonfungiblePositionManager), 0);
            uint256 refund0 = amount0 - actualAmount0;
            TransferHelper.safeTransfer(token0, msg.sender, refund0);
        }

        if (actualAmount1 < amount1) {
            TransferHelper.safeApprove(token1, address(nonfungiblePositionManager), 0);
            uint256 refund1 = amount1 - actualAmount1;
            TransferHelper.safeTransfer(token1, msg.sender, refund1);
        }
    }

it("Should create a new ETH-USDC 0.3% position", async function () {
            
            const FEE = 3000;
            
            const { contract, owner } = await loadFixture(deployUniswapPoolFixture) 
            const ethAmount = 10n**18n;
            const usdcAmount = 3000n * 10n ** 6n;

            const tickLower = -887272 // Math.ceil(baseLog(BASE, Math.sqrt(1/1400)));
            const tickUpper = -tickLower // Math.ceil(baseLog(BASE, Math.sqrt(1/1200)));

            await weth.connect(owner).deposit({ value: 100n * 10n ** 18n });
            await weth.connect(owner).approve(contract.address, 100n * 10n ** 18n);

            await network.provider.request({
                method: "hardhat_impersonateAccount",
                params: [USDC_WHALE]
            })

            const usdcWhale = await ethers.getSigner(USDC_WHALE);
            expect(await usdc.balanceOf(USDC_WHALE)).to.be.greaterThan(usdcAmount);


            await usdc.connect(usdcWhale).transfer(owner.address, usdcAmount);
            await usdc.connect(owner).transfer(contract.address, usdcAmount);
            
            const newPosition = await contract.mintPosition(
                                                MAINNET_TOKENS.ETH,
                                                MAINNET_TOKENS.USDC,
                                                FEE,
                                                ethAmount,
                                                usdcAmount,
                                                tickLower,
                                                tickUpper);

            console.log(await dai.balanceOf(owner.address));

            // expect(daiBalanceAfter).to.be.equal(0);

        });

Error: Transaction reverted without a reason string
    at <UnrecognizedContract>.<unknown> (0xc36442b4a4522e871399cd717abdd847ab11fe88)
    at UniswapPool.mintPosition (contracts/uniswap/UniswapPool.sol:95)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at HardhatNode._mineBlockWithPendingTxs (node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:1802:23)
    at HardhatNode.mineBlock (node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:491:16)
    at EthModule._sendTransactionAndReturnHash (node_modules/hardhat/src/internal/hardhat-network/provider/modules/eth.ts:1522:18)
    at HardhatNetworkProvider.request (node_modules/hardhat/src/internal/hardhat-network/provider/provider.ts:118:18)
    at EthersProviderWrapper.send (node_modules/@nomiclabs/hardhat-ethers/src/internal/ethers-provider-wrapper.ts:13:20)