@merkl/api 0.20.52 → 0.20.54

package/dist/src/modules/v4/uniswap/uniswap.service.js

@@ -1,18 +1,15 @@
 import { safeFetchLogs } from "@/engine/dynamicData/utils/fetchLogs";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
 import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
-import { LoggedEntityType } from "@db/api";
-import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, UniswapV4PoolManager__factory, getContractCreationBlock, } from "@sdk";
-import { utils } from "ethers";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
 import { getAddress } from "viem";
 import { BlacklistService } from "../blacklist";
 import { ChainService } from "../chain/chain.service";
 import { MerklRootService } from "../merklRoot";
 import { OpportunityService } from "../opportunity";
 import { RewardService } from "../reward";
+import { LoggedEntityType, UniV4ChainIdArray, } from "./uniswap.model";
 import { UniswapRepository } from "./uniswap.repository";
-export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
 export class UniswapService {
     static async findV3RewardsPerPosition(query) {
         /** Check if the user is blacklisted */
@@ -52,83 +49,24 @@ export class UniswapService {
         }
         return res;
     }
-    static async getPoolsByChain(chainId) {
-        const lastBlock = await providers[chainId].getBlockNumber();
-        const logs = await safeFetchLogs(chainId, [PoolManagerInterface.getEventTopic("Initialize")], ["0xE8E23e97Fa135823143d6b9Cba9c699040D51F70"], 0, lastBlock);
-        const poolData = [];
-        const calls = [];
-        for (const log of logs) {
-            const poolId = utils.defaultAbiCoder.decode(["bytes32"], log.topics[1])[0];
-            const currency0 = utils.defaultAbiCoder.decode(["address"], log.topics[2])[0];
-            const currency1 = utils.defaultAbiCoder.decode(["address"], log.topics[3])[0];
-            const [_indexedPoolId, _indexedCurrency0, _indexedCurrency1, fee, tickSpacing, hooks, sqrtPriceX98, tick] = PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
-            poolData.push({
-                poolId,
-                poolKey: {
-                    currency0,
-                    currency1,
-                    fee,
-                    tickSpacing,
-                    hooks,
-                },
-            });
-            calls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: currency0,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: currency0,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: currency1,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: currency1,
-            });
+    static async getUniswapV4Pools(chainId) {
+        let chainIdArray;
+        if (!!chainId) {
+            chainIdArray = [chainId];
         }
-        const result = await batchMulticallCallWithRetry(chainId, { calls });
-        const res = {};
-        for (const [index, pool] of poolData.entries()) {
-            let symbolCurrency0 = "";
-            let decimalsCurrency0 = 0;
-            let symbolCurrency1 = "";
-            let decimalsCurrency1 = 0;
-            try {
-                symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4].returnData)[0];
-            }
-            catch { }
-            try {
-                decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 1].returnData)[0];
-            }
-            catch { }
-            try {
-                symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4 + 2].returnData)[0];
-            }
-            catch { }
-            try {
-                decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 3].returnData)[0];
-            }
-            catch { }
-            res[pool.poolId] = { ...pool, symbolCurrency0, decimalsCurrency0, symbolCurrency1, decimalsCurrency1 };
+        else {
+            chainIdArray = UniV4ChainIdArray;
         }
-        return res;
-    }
-    static async getPools() {
-        const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
         const pools = {};
-        // 0_ Fetch all euler vaults from database
-        const storedPools = await UniswapRepository.getStoredPools();
-        const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
+        // 0_ Fetch all univ4 pools from API database
+        const storedPools = await UniswapRepository.getStoredUniswapV4Pools(chainId);
+        const res = await Promise.all(chainIdArray.map(async (chainId) => {
             chainId = chainId;
             const perChainIdRes = {};
             const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
             const jsonRPCprovider = providers[chainId];
             try {
-                // 1_ Get latest euler vaults from chain
+                // 1_ Get latest uniswapV4 pools for `chainId`
                 const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
                 log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
                 let fromBlock;
@@ -140,12 +78,10 @@ export class UniswapService {
                 }
                 const toBlock = await jsonRPCprovider.getBlockNumber();
                 const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
-                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock
-                // fromBlock + 10_000
-                );
+                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
                 const decodedPools = await Promise.all(logs.map(async (log) => {
                     const [id, currency0, currency1, fee, tickSpacing, hooks] = UniswapV4PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
-                    // Respect typing
+                    // Match typing
                     return {
                         poolId: id,
                         chainId: chainId,
@@ -247,13 +183,13 @@ export class UniswapService {
             }
             return perChainIdRes;
         }));
-        UNIV4_CHAINIDS.forEach((chainId, i) => {
+        chainIdArray.forEach((chainId, i) => {
             if (!!res[i])
                 pools[chainId] = res[i];
         });
         // Update the API database
         const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
-        for (const chainId of UNIV4_CHAINIDS) {
+        for (const chainId of chainIdArray) {
             if (tableData.filter(p => p.chainId === chainId).length > 0) {
                 try {
                     await UniswapRepository.createMany(tableData
@@ -288,4 +224,8 @@ export class UniswapService {
         log.info("👋 exiting getUniswapV4Pools");
         return pools;
     }
+    /** @deprecated */
+    static async getUniswapV4PoolsForChain(chainId) {
+        return await UniswapService.getUniswapV4Pools(chainId);
+    }
 }

package/dist/src/routes/v3/uniswapv4.js

@@ -1,16 +1,16 @@
 import { Redis } from "@/cache";
-import { UniV4ChainIdArray, getUniswapV4Pools } from "@/engine/dynamicData/utils/getUniswapV4Pools";
 import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { Bytes32Dto } from "@/modules/v4/uniswap/uniswap.model";
+import { Bytes32Dto, UniV4ChainIdArray } from "@/modules/v4/uniswap/uniswap.model";
+import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
 import { UnsupportedNetwork } from "@/utils/error";
 export default (app) => app.group("/uniswapv4", router => router
     .get("/", async () => {
-    return await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);
+    return await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools);
 }, {
     tags: ["uniswapv4"],
 })
     .get("/:chainId", async ({ params }) => {
-    return (await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools, params.chainId))[params.chainId];
+    return (await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools, params.chainId))[params.chainId];
 }, {
     params: ChainUniqueDto,
     beforeHandle: ({ params }) => {
@@ -20,7 +20,7 @@ export default (app) => app.group("/uniswapv4", router => router
     tags: ["uniswapv4"],
 })
     .get("/pool/:poolId", async ({ params }) => {
-    return Object.values((await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools)))
+    return Object.values((await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools)))
         .flatMap(x => (x ? Object.values(x) : []))
         .filter(p => p.poolId === params.poolId);
 }, {