add isValidPool tests

Author: zishansami102

contracts/protocol/integration/amm/ArrakisUniswapV3AmmAdapter.sol

@@ -231,38 +231,20 @@ contract ArrakisUniswapV3AmmAdapter is IAmmAdapter {
 
         // Make sure the tokens stored in the arrakis pools matches the
         // tokens provided in the components
-        if(
+        if (
             _components.length != 2 ||
             !(token0 == _components[0] || token0 == _components[1]) ||
             !(token1 == _components[0] || token1 == _components[1])
         ) {
             return false;
         }
 
-        // Attempt to get the UniswapV3 pool in the provided Arrakis pool
-        IUniswapV3Pool uniV3PairPool;
-        try IArrakisVaultV1(_pool).pool() returns (IUniswapV3Pool _uniV3PairPool) {
-            uniV3PairPool = _uniV3PairPool;
+        // Make sure the pool address follows IERC20 interface
+        try IArrakisVaultV1(_pool).totalSupply() returns (uint256 _totalSupply) {
         } catch {
             return false;
         }
-
-        // Attempt to get the UniswapV3 pool fee from the UniV3 pool stored in Arrakis pool
-        uint24 uniFee;
-        try uniV3PairPool.fee() returns (uint24 _uniFee) {
-            uniFee = _uniFee;
-        } catch {
-            return false;
-        }
-
-        // Make sure that the pool address returned by the factory 
-        // matches uniswapV3 pool address stored in the provided arrakis pool
-        if(
-            uniV3Factory.getPool(_components[0], _components[1], uniFee) != address(uniV3PairPool)
-        ) {
-            return false;
-        }
-
+        
         return true;
     }
 }

test/protocol/integration/amm/ArrakisUniswapV3AmmAdapter.spec.ts

@@ -120,4 +120,68 @@ describe("ArrakisUniswapV3AmmAdapter", () => {
     });
   });
 
+  describe("isValidPool", async () => {
+    let subjectAmmPool: Address;
+    let subjectComponents: Address[];
+
+    beforeEach(async () => {
+      subjectAmmPool = arrakisV1Setup.wethDaiPool.address;
+      subjectComponents = [setup.weth.address, setup.dai.address];
+    });
+
+    async function subject(): Promise<any> {
+      return await arrakisUniswapV3AmmAdapter.isValidPool(subjectAmmPool, subjectComponents);
+    }
+
+    it("should be a valid pool", async () => {
+      const status = await subject();
+      expect(status).to.be.true;
+    });
+
+    describe("when the pool address is invalid", async () => {
+      beforeEach(async () => {
+        subjectAmmPool = setup.weth.address;
+      });
+
+      it("should be an invalid pool", async () => {
+        const status = await subject();
+        expect(status).to.be.false;
+      });
+    });
+
+    describe("when the components don't match", async () => {
+      beforeEach(async () => {
+        subjectComponents = [setup.weth.address, setup.wbtc.address];
+      });
+
+      it("should be an invalid pool", async () => {
+        const status = await subject();
+        expect(status).to.be.false;
+      });
+    });
+
+    describe("when the number of components is incorrect", async () => {
+      beforeEach(async () => {
+        subjectComponents = [setup.weth.address];
+      });
+
+      it("should be an invalid pool", async () => {
+        const status = await subject();
+        expect(status).to.be.false;
+      });
+    });
+
+    describe("when the pool address is not an ERC20", async () => {
+      beforeEach(async () => {
+        subjectAmmPool = uniswapV3Setup.wethDaiPool.address;
+      });
+
+      it("should be an invalid pool", async () => {
+        const status = await subject();
+        expect(status).to.be.false;
+      });
+    });
+
+  });
+
 });

utils/deploys/deployExternal.ts

@@ -759,6 +759,10 @@ export default class DeployExternalContracts {
     return await new GUniRouter__factory(this._deployerSigner).deploy(uniswapV3factory, weth);
   }
 
+  public async deployArrakisVaultV1(_gelato: Address, _arrakisTreasury: Address): Promise<ArrakisVaultV1> {
+    return await new ArrakisVaultV1__factory(this._deployerSigner).deploy(_gelato, _arrakisTreasury);
+  }
+
   public async getArrakisVaultV1Instance(pool: Address): Promise<ArrakisVaultV1> {
     return await new ArrakisVaultV1__factory(this._deployerSigner).attach(pool);
   }

utils/fixtures/arrakisV1Fixture.ts

@@ -1,5 +1,4 @@
 import DeployHelper from "../deploys";
-// import { MAX_UINT_256 } from "../constants";
 import { Signer, providers } from "ethers";
 import { Address } from "../types";
 import { Account } from "../test/types";
@@ -10,13 +9,9 @@ import {
   ArrakisVaultV1
 } from "../contracts/arrakis";
 
-// import { UniswapV3Pool } from "../contracts/uniswapV3";
 import { UniswapV3Fixture } from "@utils/fixtures";
-// import { UniswapV3Pool__factory } from "../../typechain/factories/UniswapV3Pool__factory";
-// import { ether } from "../index";
 import { StandardTokenMock } from "../../typechain/StandardTokenMock";
 import { WETH9 } from "../../typechain/WETH9";
-// import { parseEther } from "ethers/lib/utils";
 
 type Token = StandardTokenMock | WETH9;
 
@@ -62,17 +57,34 @@ export class ArrakisV1Fixture {
     _wbtcPrice: number,
     _dai: Token
   ): Promise<void> {
-    this.factory = await this._deployer.external.deployArrakisFactoryV1(_uniswapV3Setup.factory.address);
+    await this.deployVaultAndFactoryAndinitialize(_owner, _uniswapV3Setup);
     this.router = await this._deployer.external.deployGUniRouter(_uniswapV3Setup.factory.address, _weth.address);
 
     this.wethDaiPool = await this.createNewPair(_owner, _uniswapV3Setup,  _weth, _dai, 3000, _wethPrice);
     this.wethWbtcPool = await this.createNewPair(_owner, _uniswapV3Setup, _weth, _wbtc, 3000, _wethPrice / _wbtcPrice);
   }
 
+  /**
+   * Creates and initializes a new arrakis factory
+   *
+   * @param _owner          the owner of the deployed Arrakis system
+   * @param _uniswapV3Setup uniswapV3Fixture
+   * @returns               a new Arrakis Vault holding UniswapV3 position on given tokens
+   */
+  public async deployVaultAndFactoryAndinitialize(
+    _owner: Account,
+    _uniswapV3Setup: UniswapV3Fixture
+  ): Promise<void> {
+    const vaultImplementation = await this._deployer.external.deployArrakisVaultV1(_owner.address, _owner.address);
+    this.factory = await this._deployer.external.deployArrakisFactoryV1(_uniswapV3Setup.factory.address);
+    await this.factory.initialize(vaultImplementation.address, _owner.address);
+  }
+
   /**
    * Creates and initializes a new arrakis vault pool
    *
    * @param _owner          the owner of the deployed Arrakis system
+   * @param _uniswapV3Setup uniswapV3Fixture
    * @param _token0         first token
    * @param _token1         second token
    * @param _fee            fee tier of either 500, 3000, or 10000