feat(pools): speed up cmd by only querying relevant zrc20 pools

package.json

@@ -112,5 +112,6 @@
     "spinnies": "^0.5.1",
     "tiny-secp256k1": "^2.2.3",
     "ws": "^8.13.0"
-  }
-}
+  },
+  "packageManager": "[email protected]+sha1.1959a18351b811cdeedbd484a8f86c3cc3bbaf72"
+}

packages/client/src/getPools.ts

@@ -1,53 +1,88 @@
 import UniswapV2Factory from "@uniswap/v2-core/build/UniswapV2Factory.json";
 import UniswapV2Pair from "@uniswap/v2-core/build/UniswapV2Pair.json";
 import { getAddress, ParamChainName } from "@zetachain/protocol-contracts";
+import SystemContract from "@zetachain/protocol-contracts/abi/zevm/SystemContract.sol/SystemContract.json";
 import { ethers } from "ethers";
 
 import { ZetaChainClient } from "./client";
 
 export const getPools = async function (this: ZetaChainClient) {
   const rpc = this.getEndpoint("evm", `zeta_${this.network}`);
   const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
-
-  const uniswapV2FactoryAddress = getAddress(
-    "uniswapV2Factory",
-    `zeta_${this.network}` as ParamChainName
-  );
+  const zetaNetwork = `zeta_${this.network}` as ParamChainName;
+  const uniswapV2FactoryAddress = getAddress("uniswapV2Factory", zetaNetwork);
 
   if (!uniswapV2FactoryAddress) {
     throw new Error("uniswapV2Factory is not defined");
   }
 
-  const UniswapV2FactoryContract = new ethers.Contract(
-    uniswapV2FactoryAddress,
-    UniswapV2Factory.abi,
+  const systemContractAddress = getAddress("systemContract", zetaNetwork);
+  if (!systemContractAddress) {
+    throw new Error("System contract is not defined");
+  }
+
+  const systemContract = new ethers.Contract(
+    systemContractAddress,
+    SystemContract.abi,
     provider
   );
 
-  const totalPairs = await UniswapV2FactoryContract.allPairsLength();
-  let pairs = [];
-  for (let i = 0; i < totalPairs; i++) {
-    pairs.push(await UniswapV2FactoryContract.allPairs(i));
+  const zetaTokenAddress = getAddress("zetaToken", zetaNetwork);
+  if (!zetaTokenAddress) {
+    throw new Error("ZETA token address is not defined");
   }
 
-  const poolPromises = pairs.map(async (pair: any) => {
-    let pool = {
-      pair,
-      t0: {},
-      t1: {},
-    } as any;
-    const pairContract = new ethers.Contract(pair, UniswapV2Pair.abi, provider);
+  const foreignCoins = await this.getForeignCoins();
+  const tokenAddresses = foreignCoins.map(
+    (coin: any) => coin.zrc20_contract_address
+  );
+  tokenAddresses.push(zetaTokenAddress);
+
+  const poolPromises = [];
 
-    pool.t0.address = await pairContract.token0();
-    pool.t1.address = await pairContract.token1();
+  for (let i = 0; i < tokenAddresses.length; i++) {
+    for (let j = i + 1; j < tokenAddresses.length; j++) {
+      const tokenA = tokenAddresses[i];
+      const tokenB = tokenAddresses[j];
 
-    const reserves = await pairContract.getReserves();
-    pool.t0.reserve = reserves[0];
-    pool.t1.reserve = reserves[1];
+      const poolPromise = (async () => {
+        const pair = await systemContract.uniswapv2PairFor(
+          uniswapV2FactoryAddress,
+          tokenA,
+          tokenB
+        );
 
-    return pool;
-  });
+        if (pair === ethers.constants.AddressZero) {
+          return null;
+        }
+
+        try {
+          const pairContract = new ethers.Contract(
+            pair,
+            UniswapV2Pair.abi,
+            provider
+          );
+          const token0 = await pairContract.token0();
+          const token1 = await pairContract.token1();
+          const reserves = await pairContract.getReserves();
+
+          return {
+            pair,
+            t0: { address: token0, reserve: reserves[0] },
+            t1: { address: token1, reserve: reserves[1] },
+          };
+        } catch (error) {
+          return null;
+        }
+      })();
+
+      poolPromises.push(poolPromise);
+    }
+  }
+
+  const pools = (await Promise.all(poolPromises)).filter(
+    (pool) => pool !== null
+  );
 
-  const pools = await Promise.all(poolPromises);
   return pools;
 };

packages/tasks/src/pools.ts

@@ -47,8 +47,8 @@ const main = async (args: any, hre: HardhatRuntimeEnvironment) => {
 
   const tableData = {} as any;
   poolsWithSymbolsAndDecimals.forEach((pool: any) => {
-    const r0 = parseFloat(pool.t0.reserve).toFixed(2);
-    const r1 = parseFloat(pool.t1.reserve).toFixed(2);
+    const r0 = parseFloat(pool.t0.reserve);
+    const r1 = parseFloat(pool.t1.reserve);
 
     tableData[pool.pair] = {
       Pool: `${pool.t0.symbol} / ${pool.t1.symbol}`,