[WONT MERGE]: Exclude deprecated markets from PoolLens

contracts/Lens/PoolLens.sol

@@ -136,12 +136,22 @@ contract PoolLens is ExponentialNoError, TimeManagerV8 {
         BadDebt[] badDebts;
     }
 
+    /// @notice Address of the core pool comptroller (all markets are returned for this pool, including paused ones)
+    address public immutable corePoolComptroller;
+
     /**
      * @param timeBased_ A boolean indicating whether the contract is based on time or block.
      * @param blocksPerYear_ The number of blocks per year
+     * @param corePoolComptroller_ The address of the core pool comptroller
      * @custom:oz-upgrades-unsafe-allow constructor
      */
-    constructor(bool timeBased_, uint256 blocksPerYear_) TimeManagerV8(timeBased_, blocksPerYear_) {}
+    constructor(
+        bool timeBased_,
+        uint256 blocksPerYear_,
+        address corePoolComptroller_
+    ) TimeManagerV8(timeBased_, blocksPerYear_) {
+        corePoolComptroller = corePoolComptroller_;
+    }
 
     /**
      * @notice Queries the user's supply/borrow balances in vTokens
@@ -250,7 +260,7 @@ contract PoolLens is ExponentialNoError, TimeManagerV8 {
         address account,
         address comptrollerAddress
     ) external view returns (RewardSummary[] memory) {
-        VToken[] memory markets = ComptrollerInterface(comptrollerAddress).getAllMarkets();
+        VToken[] memory markets = _getMarkets(ComptrollerInterface(comptrollerAddress));
         RewardsDistributor[] memory rewardsDistributors = ComptrollerViewInterface(comptrollerAddress)
             .getRewardDistributors();
         RewardSummary[] memory rewardSummary = new RewardSummary[](rewardsDistributors.length);
@@ -276,9 +286,9 @@ contract PoolLens is ExponentialNoError, TimeManagerV8 {
     function getPoolBadDebt(address comptrollerAddress) external view returns (BadDebtSummary memory) {
         uint256 totalBadDebtUsd;
 
-        // Get every market in the pool
+        // Get every listed market in the pool
         ComptrollerViewInterface comptroller = ComptrollerViewInterface(comptrollerAddress);
-        VToken[] memory markets = comptroller.getAllMarkets();
+        VToken[] memory markets = _getMarkets(ComptrollerInterface(comptrollerAddress));
         ResilientOracleInterface priceOracle = comptroller.oracle();
 
         BadDebt[] memory badDebts = new BadDebt[](markets.length);
@@ -344,7 +354,7 @@ contract PoolLens is ExponentialNoError, TimeManagerV8 {
         // Get tokens in the Pool
         ComptrollerInterface comptrollerInstance = ComptrollerInterface(venusPool.comptroller);
 
-        VToken[] memory vTokens = comptrollerInstance.getAllMarkets();
+        VToken[] memory vTokens = _getMarkets(comptrollerInstance);
 
         VTokenMetadata[] memory vTokenMetadataItems = vTokenMetadataAll(vTokens);
 
@@ -453,6 +463,37 @@ contract PoolLens is ExponentialNoError, TimeManagerV8 {
             });
     }
 
+    /**
+     * @notice Returns markets from a comptroller. For the core pool, all markets are returned.
+     * For other pools, markets with zero internalCash are filtered.
+     * @param comptroller The comptroller to query
+     * @return An array of VToken addresses
+     */
+    function _getMarkets(ComptrollerInterface comptroller) internal view returns (VToken[] memory) {
+        VToken[] memory allMarkets = comptroller.getAllMarkets();
+
+        if (address(comptroller) == corePoolComptroller) {
+            return allMarkets;
+        }
+
+        // Single-loop filter: pack active markets to the front of allMarkets
+        uint256 count;
+        uint256 len = allMarkets.length;
+        for (uint256 i; i < len; ++i) {
+            if (allMarkets[i].internalCash() > 0) {
+                allMarkets[count] = allMarkets[i];
+                ++count;
+            }
+        }
+
+        // Trim the array to the active count
+        assembly {
+            mstore(allMarkets, count)
+        }
+
+        return allMarkets;
+    }
+
     function _calculateNotDistributedAwards(
         address account,
         VToken[] memory markets,

deploy/007-deploy-pool-lens.ts

@@ -10,14 +10,36 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
 
   const { isTimeBased, blocksPerYear } = getBlockOrTimestampBasedDeploymentInfo(hre.getNetworkName());
 
-  await deploy("PoolLens", {
+  const corePoolComptroller = await deployments.get("Comptroller_Core");
+  const constructorArgs = [isTimeBased, blocksPerYear, corePoolComptroller.address];
+
+  const poolLens = await deploy("PoolLens", {
     from: deployer,
-    args: [isTimeBased, blocksPerYear],
+    args: constructorArgs,
     log: true,
     autoMine: true,
+    skipIfAlreadyDeployed: true,
   });
+
+  if (poolLens.newlyDeployed) {
+    console.log("Verifying PoolLens...");
+    try {
+      await hre.run("verify:verify", {
+        address: poolLens.address,
+        constructorArguments: constructorArgs,
+      });
+      console.log("PoolLens verified successfully");
+    } catch (error: any) {
+      if (error.message.includes("Already Verified")) {
+        console.log("PoolLens already verified");
+      } else {
+        console.error("Verification failed:", error.message);
+      }
+    }
+  }
 };
 
 func.tags = ["PoolLens", "il"];
+func.skip = async (hre: HardhatRuntimeEnvironment) => !hre.network.live;
 
 export default func;

tests/hardhat/Fork/PoolLensForkTest.ts

@@ -0,0 +1,164 @@
+import chai from "chai";
+import { ethers } from "hardhat";
+
+import {
+  Comptroller,
+  Comptroller__factory,
+  PoolLens,
+  PoolLens__factory,
+  PoolRegistry__factory,
+} from "../../../typechain";
+import { getContractAddresses, setForkBlock } from "./utils";
+
+const { expect } = chai;
+
+const FORK = process.env.FORK === "true";
+const FORKED_NETWORK = process.env.FORKED_NETWORK || "bscmainnet";
+
+const { POOL_REGISTRY, COMPTROLLER, CORE_COMPTROLLER, ACC1, BLOCK_NUMBER } = getContractAddresses(
+  FORKED_NETWORK as string,
+);
+
+// BSC uses block-based, Arbitrum/Optimism/Base/zkSync use time-based
+const TIME_BASED_NETWORKS = [
+  "arbitrumone",
+  "arbitrumsepolia",
+  "zksyncmainnet",
+  "zksyncsepolia",
+  "opmainnet",
+  "opsepolia",
+  "basemainnet",
+  "basesepolia",
+  "unichainmainnet",
+  "unichainsepolia",
+];
+
+const isTimeBased = TIME_BASED_NETWORKS.includes(FORKED_NETWORK);
+const BSC_BLOCKS_PER_YEAR = 70_080_000;
+const ETH_BLOCKS_PER_YEAR = 2_628_000;
+const OPBNB_BLOCKS_PER_YEAR = 126_144_000;
+
+function getBlocksPerYear(network: string): number {
+  if (TIME_BASED_NETWORKS.includes(network)) return 0;
+  if (network.includes("opbnb")) return OPBNB_BLOCKS_PER_YEAR;
+  if (network === "ethereum" || network === "sepolia") return ETH_BLOCKS_PER_YEAR;
+  return BSC_BLOCKS_PER_YEAR;
+}
+
+if (FORK) {
+  describe(`PoolLens Fork Test (${FORKED_NETWORK})`, function () {
+    this.timeout(120_000); // fork tests need more time due to RPC calls
+    let poolLens: PoolLens;
+    let comptroller: Comptroller;
+
+    before(async () => {
+      await setForkBlock(BLOCK_NUMBER);
+
+      const poolLensFactory = (await ethers.getContractFactory("PoolLens")) as PoolLens__factory;
+      poolLens = await poolLensFactory.deploy(
+        isTimeBased,
+        getBlocksPerYear(FORKED_NETWORK),
+        CORE_COMPTROLLER || ethers.constants.AddressZero,
+      );
+      await poolLens.deployed();
+
+      comptroller = Comptroller__factory.connect(CORE_COMPTROLLER, ethers.provider);
+    });
+
+    describe("getAllPools", () => {
+      it("should not revert", async () => {
+        const pools = await poolLens.getAllPools(POOL_REGISTRY);
+        expect(pools.length).to.be.greaterThan(0);
+
+        for (const pool of pools) {
+          expect(pool.comptroller).to.not.equal(ethers.constants.AddressZero);
+        }
+      });
+    });
+
+    describe("getPoolByComptroller", () => {
+      it("should not revert and return all markets for core pool", async () => {
+        const pool = await poolLens.getPoolByComptroller(POOL_REGISTRY, CORE_COMPTROLLER);
+        expect(pool.comptroller).to.equal(CORE_COMPTROLLER);
+        expect(pool.vTokens.length).to.be.greaterThan(0);
+        for (const vToken of pool.vTokens) {
+          expect(vToken.isListed).to.equal(true);
+        }
+      });
+    });
+
+    describe("getPendingRewards", () => {
+      it("should not revert", async () => {
+        const account = ACC1 || ethers.constants.AddressZero;
+        const rewards = await poolLens.getPendingRewards(account, CORE_COMPTROLLER);
+        expect(rewards).to.be.an("array");
+      });
+    });
+
+    describe("getPoolBadDebt", () => {
+      it("should not revert", async () => {
+        const badDebtSummary = await poolLens.getPoolBadDebt(CORE_COMPTROLLER);
+        expect(badDebtSummary.comptroller).to.equal(CORE_COMPTROLLER);
+        expect(badDebtSummary.badDebts).to.be.an("array");
+        for (const badDebt of badDebtSummary.badDebts) {
+          expect(badDebt.vTokenAddress).to.not.equal(ethers.constants.AddressZero);
+        }
+      });
+    });
+
+    describe("vTokenMetadataAll", () => {
+      it("should not revert for markets in pool", async () => {
+        const allMarkets = await comptroller.getAllMarkets();
+
+        if (allMarkets.length > 0) {
+          const metadata = await poolLens.vTokenMetadataAll(allMarkets);
+          expect(metadata.length).to.equal(allMarkets.length);
+        }
+      });
+    });
+
+    describe("getPoolDataFromVenusPool", () => {
+      it("should not revert", async () => {
+        const poolRegistry = PoolRegistry__factory.connect(POOL_REGISTRY, ethers.provider);
+        const venusPool = await poolRegistry.getPoolByComptroller(CORE_COMPTROLLER);
+        const poolData = await poolLens.getPoolDataFromVenusPool(POOL_REGISTRY, venusPool);
+        expect(poolData.comptroller).to.equal(CORE_COMPTROLLER);
+      });
+    });
+
+    describe("non-core pool filters out vTokens with internalCash == 0", () => {
+      it("should not include vTokens with zero internalCash for non-core pools", async () => {
+        if (COMPTROLLER === CORE_COMPTROLLER) {
+          return;
+        }
+
+        const pools = await poolLens.getAllPools(POOL_REGISTRY);
+        for (const pool of pools) {
+          if (pool.comptroller === CORE_COMPTROLLER) continue;
+
+          for (const vToken of pool.vTokens) {
+            expect(vToken.totalCash).to.be.gt(0, `vToken ${vToken.vToken} in pool ${pool.comptroller} has zero cash`);
+          }
+        }
+      });
+    });
+
+    describe("core pool includes all markets", () => {
+      it("should include all markets for core pool", async () => {
+        if (!CORE_COMPTROLLER || CORE_COMPTROLLER === ethers.constants.AddressZero) {
+          return;
+        }
+
+        const coreComptroller = Comptroller__factory.connect(CORE_COMPTROLLER, ethers.provider);
+        const allMarkets = await coreComptroller.getAllMarkets();
+        const pool = await poolLens.getPoolByComptroller(POOL_REGISTRY, CORE_COMPTROLLER);
+        const returnedAddresses = pool.vTokens.map(v => v.vToken.toLowerCase());
+
+        expect(returnedAddresses.length).to.equal(allMarkets.length);
+        for (const market of allMarkets) {
+          expect(returnedAddresses).to.include(market.toLowerCase());
+        }
+      });
+    });
+  });
+}