Add Inverted Quoter for AMO fork test.

contracts/contracts/utils/AerodromeAMOQuoter.sol

@@ -40,7 +40,7 @@ contract QuoterHelper {
     ////////////////////////////////////////////////////////////////
     uint256 public constant BINARY_MIN_AMOUNT = 1 wei;
     uint256 public constant BINARY_MAX_AMOUNT_FOR_REBALANCE = 3_000 ether;
-    uint256 public constant BINARY_MAX_AMOUNT_FOR_PUSH_PRICE = 1_000 ether;
+    uint256 public constant BINARY_MAX_AMOUNT_FOR_PUSH_PRICE = 50_000 ether;
 
     uint256 public constant BINARY_MAX_ITERATIONS = 100;
     uint256 public constant PERCENTAGE_BASE = 1e18; // 100%
@@ -338,12 +338,18 @@ contract QuoterHelper {
 
     /// @notice Get the amount of tokens to swap to reach the target price.
     /// @dev This act like a quoter, i.e. the transaction is not performed.
+    /// @dev Because the amount to swap can be largely overestimated, because CLAMM alow partial orders,
+    /// i.e. when we ask to swap a very large amount, with a close priceLimite, it will swap only a part of it,
+    /// and not revert. So if overestimated amount is to high, use a custom maxAmount to avoid this issue.
     /// @param sqrtPriceTargetX96 The target price to reach.
     /// @return amount The amount of tokens to swap.
     /// @return iterations The number of iterations to find the amount.
     /// @return swapWETHForOETHB True if we need to swap WETH for OETHb, false otherwise.
     /// @return sqrtPriceX96After The price after the swap.
-    function getAmountToSwapToReachPrice(uint160 sqrtPriceTargetX96)
+    function getAmountToSwapToReachPrice(
+        uint160 sqrtPriceTargetX96,
+        uint256 maxAmount
+    )
         public
         returns (
             uint256,
@@ -354,7 +360,9 @@ contract QuoterHelper {
     {
         uint256 iterations;
         uint256 low = BINARY_MIN_AMOUNT;
-        uint256 high = BINARY_MAX_AMOUNT_FOR_PUSH_PRICE;
+        uint256 high = maxAmount == 0
+            ? BINARY_MAX_AMOUNT_FOR_PUSH_PRICE
+            : maxAmount;
         bool swapWETHForOETHB = getSwapDirection(sqrtPriceTargetX96);
 
         while (low <= high && iterations < BINARY_MAX_ITERATIONS) {
@@ -557,6 +565,32 @@ contract AerodromeAMOQuoter {
         }
     }
 
+    /// @notice Use this to get the amount to swap to reach the target price after swap.
+    /// @dev This call will only revert, check the logs to get returned values.
+    /// @param sqrtPriceTargetX96 The target price to reach.
+    /// @param maxAmount The maximum amount to swap. (See QuoterHelper for more details)
+    function quoteAmountToSwapToReachPrice(
+        uint160 sqrtPriceTargetX96,
+        uint256 maxAmount
+    ) public {
+        (
+            uint256 amount,
+            uint256 iterations,
+            bool swapWETHForOETHB,
+            uint160 sqrtPriceAfterX96
+        ) = quoterHelper.getAmountToSwapToReachPrice(
+                sqrtPriceTargetX96,
+                maxAmount
+            );
+
+        emit ValueFoundBis(
+            amount,
+            iterations,
+            swapWETHForOETHB,
+            sqrtPriceAfterX96
+        );
+    }
+
     /// @notice Use this to get the amount to swap to reach the target price after swap.
     /// @dev This call will only revert, check the logs to get returned values.
     /// @param sqrtPriceTargetX96 The target price to reach.
@@ -566,7 +600,7 @@ contract AerodromeAMOQuoter {
             uint256 iterations,
             bool swapWETHForOETHB,
             uint160 sqrtPriceAfterX96
-        ) = quoterHelper.getAmountToSwapToReachPrice(sqrtPriceTargetX96);
+        ) = quoterHelper.getAmountToSwapToReachPrice(sqrtPriceTargetX96, 0);
 
         emit ValueFoundBis(
             amount,

contracts/test/_fixture-base.js

@@ -140,7 +140,8 @@ const defaultBaseFixture = deployments.createFixture(async () => {
   for (const user of [rafael, nick]) {
     // Mint some bridged WOETH
     await woeth.connect(minter).mint(user.address, oethUnits("1"));
-    await weth.connect(user).deposit({ value: oethUnits("5000") });
+    await hhHelpers.setBalance(user.address, oethUnits("10000000"));
+    await weth.connect(user).deposit({ value: oethUnits("100000") });
 
     // Set allowance on the vault
     await weth.connect(user).approve(oethbVault.address, oethUnits("50"));

contracts/test/strategies/aerodrome-amo.base.fork-test.js

@@ -44,10 +44,10 @@ describe("ForkTest: Aerodrome AMO Strategy empty pool setup (Base)", function ()
 
     await weth
       .connect(rafael)
-      .approve(aeroSwapRouter.address, oethUnits("1000"));
+      .approve(aeroSwapRouter.address, oethUnits("1000000000"));
     await oethb
       .connect(rafael)
-      .approve(aeroSwapRouter.address, oethUnits("1000"));
+      .approve(aeroSwapRouter.address, oethUnits("1000000000"));
   });
 
   // Haven't found away to test for this in the strategy contract yet
@@ -70,17 +70,51 @@ describe("ForkTest: Aerodrome AMO Strategy empty pool setup (Base)", function ()
     ).to.be.revertedWith("Can not rebalance empty pool");
   });
 
-  it.skip("Should be reverted trying to rebalance and we are not in the correct tick", async () => {
-    // Push price to tick 0, which is OutisdeExpectedTickRange
-    const { value, direction } = await quoteAmountToSwapToReachPrice(
-      await aerodromeAmoStrategy.sqrtRatioX96TickHigher()
+  it("Should be reverted trying to rebalance and we are not in the correct tick, below", async () => {
+    // Push price to tick -2, which is OutisdeExpectedTickRange
+    const priceAtTickM2 = BigNumber.from("79220240490215316061937756561"); // tick -2
+    const { value, direction } = await quoteAmountToSwapToReachPrice({
+      price: priceAtTickM2,
+      maxAmount: 0,
+    });
+    await swap({
+      amount: value,
+      swapWeth: direction,
+      priceLimit: priceAtTickM2,
+    });
+
+    // Ensure the price has been pushed enough
+    expect(await aerodromeAmoStrategy.getPoolX96Price()).to.be.eq(
+      priceAtTickM2
     );
-    await swap({ amount: value, swapWeth: direction });
 
     await expect(
       aerodromeAmoStrategy
         .connect(strategist)
-        .rebalance(oethUnits("0"), false, oethUnits("0"))
+        .rebalance(oethUnits("0"), direction, oethUnits("0"))
+    ).to.be.revertedWith("OutsideExpectedTickRange");
+  });
+
+  it("Should be reverted trying to rebalance and we are not in the correct tick, above", async () => {
+    // Push price to tick 1, which is OutisdeExpectedTickRange
+    const priceAtTick1 = BigNumber.from("79232123823359799118286999568"); // tick 1
+    const { value, direction } = await quoteAmountToSwapToReachPrice({
+      price: priceAtTick1,
+      maxAmount: 0,
+    });
+    await swap({
+      amount: value,
+      swapWeth: direction,
+      priceLimit: priceAtTick1,
+    });
+
+    // Ensure the price has been pushed enough
+    expect(await aerodromeAmoStrategy.getPoolX96Price()).to.be.eq(priceAtTick1);
+
+    await expect(
+      aerodromeAmoStrategy
+        .connect(strategist)
+        .rebalance(oethUnits("0"), direction, oethUnits("0"))
     ).to.be.revertedWith("OutsideExpectedTickRange");
   });
 
@@ -118,8 +152,17 @@ describe("ForkTest: Aerodrome AMO Strategy empty pool setup (Base)", function ()
     });
   };
 
-  const quoteAmountToSwapToReachPrice = async (price) => {
-    const txResponse = await quoter.quoteAmountToSwapToReachPrice(price);
+  const quoteAmountToSwapToReachPrice = async ({ price, maxAmount }) => {
+    let txResponse;
+    if (maxAmount == 0) {
+      txResponse = await quoter["quoteAmountToSwapToReachPrice(uint160)"](
+        price
+      );
+    } else {
+      txResponse = await quoter[
+        "quoteAmountToSwapToReachPrice(uint160,uint256)"
+      ](price, maxAmount);
+    }
     const txReceipt = await txResponse.wait();
     const [transferEvent] = txReceipt.events;
     const value = transferEvent.args.value;
@@ -128,7 +171,7 @@ describe("ForkTest: Aerodrome AMO Strategy empty pool setup (Base)", function ()
     return { value, direction, priceReached };
   };
 
-  const swap = async ({ amount, swapWeth }) => {
+  const swap = async ({ amount, swapWeth, priceLimit }) => {
     // Check if rafael as enough token to perfom swap
     // If not, mint some
     const balanceOETHb = await oethb.balanceOf(rafael.address);
@@ -151,9 +194,12 @@ describe("ForkTest: Aerodrome AMO Strategy empty pool setup (Base)", function ()
       deadline: 9999999999,
       amountIn: amount,
       amountOutMinimum: 0, // slippage check
-      sqrtPriceLimitX96: swapWeth
-        ? sqrtRatioX96TickM1000
-        : sqrtRatioX96Tick1000,
+      sqrtPriceLimitX96:
+        priceLimit == 0
+          ? swapWeth
+            ? sqrtRatioX96TickM1000
+            : sqrtRatioX96Tick1000
+          : priceLimit,
     });
   };
 });
@@ -193,10 +239,10 @@ describe("ForkTest: Aerodrome AMO Strategy (Base)", function () {
     await setup();
     await weth
       .connect(rafael)
-      .approve(aeroSwapRouter.address, oethUnits("1000"));
+      .approve(aeroSwapRouter.address, oethUnits("1000000000"));
     await oethb
       .connect(rafael)
-      .approve(aeroSwapRouter.address, oethUnits("1000"));
+      .approve(aeroSwapRouter.address, oethUnits("1000000000"));
   });
 
   describe("ForkTest: Initial state (Base)", function () {
@@ -715,7 +761,10 @@ describe("ForkTest: Aerodrome AMO Strategy (Base)", function () {
     it("Should be able to rebalance the pool when price pushed to 1:1", async () => {
       const priceAtTick0 = await aerodromeAmoStrategy.sqrtRatioX96TickHigher();
       let { value: value0, direction: direction0 } =
-        await quoteAmountToSwapToReachPrice(priceAtTick0);
+        await quoteAmountToSwapToReachPrice({
+          price: priceAtTick0,
+          maxAmount: oethUnits("2000"),
+        });
       await swap({
         amount: value0,
         swapWeth: direction0,
@@ -737,7 +786,10 @@ describe("ForkTest: Aerodrome AMO Strategy (Base)", function () {
       const priceAtTickLower =
         await aerodromeAmoStrategy.sqrtRatioX96TickLower();
       let { value: value0, direction: direction0 } =
-        await quoteAmountToSwapToReachPrice(priceAtTickLower);
+        await quoteAmountToSwapToReachPrice({
+          price: priceAtTickLower,
+          maxAmount: oethUnits("2000"),
+        });
       await swap({
         amount: value0,
         swapWeth: direction0,
@@ -939,8 +991,17 @@ describe("ForkTest: Aerodrome AMO Strategy (Base)", function () {
   //   console.log("price of OETHb   : ", displayedPoolPrice);
   // };
 
-  const quoteAmountToSwapToReachPrice = async (price) => {
-    const txResponse = await quoter.quoteAmountToSwapToReachPrice(price);
+  const quoteAmountToSwapToReachPrice = async ({ price, maxAmount }) => {
+    let txResponse;
+    if (maxAmount == 0) {
+      txResponse = await quoter["quoteAmountToSwapToReachPrice(uint160)"](
+        price
+      );
+    } else {
+      txResponse = await quoter[
+        "quoteAmountToSwapToReachPrice(uint160,uint256)"
+      ](price, maxAmount);
+    }
     const txReceipt = await txResponse.wait();
     const [transferEvent] = txReceipt.events;
     const value = transferEvent.args.value;