@merkl/api 0.18.14 → 0.19.1

package/dist/src/modules/v4/uniswapV4/uniswapV4.service.d.ts

@@ -1,4 +1,5 @@
 import { type MerklChainId } from "@sdk";
+import type { UniswapV4PoolsReturnType } from "./uniswapV4.model";
 export declare const PoolManagerInterface: any;
 export declare abstract class UniswapV4Service {
     static getPoolsByChain(chainId: MerklChainId): Promise<{
@@ -6,10 +7,10 @@ export declare abstract class UniswapV4Service {
             poolId: string;
             poolKey: {
                 hooks: string;
-                fee: number;
-                tickSpacing: number;
                 currency0: string;
                 currency1: string;
+                fee: number;
+                tickSpacing: number;
             };
             decimalsCurrency0: number;
             decimalsCurrency1: number;
@@ -17,4 +18,5 @@ export declare abstract class UniswapV4Service {
             symbolCurrency1: string;
         };
     }>;
+    static getPools(): Promise<UniswapV4PoolsReturnType>;
 }

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

@@ -1,8 +1,11 @@
 import { safeFetchLogs } from "@/libs/campaigns/utils/fetchLogs";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
+import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
-import { ERC20Interface, UniswapV4PoolManager__factory } from "@sdk";
+import { LoggedEntityType } from "@db/api";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, UniswapV4PoolManager__factory, getContractCreationBlock, } from "@sdk";
 import { utils } from "ethers";
+import { UniswapV4Repository } from "./uniswapV4.repository";
 export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
 export class UniswapV4Service {
     static async getPoolsByChain(chainId) {
@@ -70,4 +73,175 @@ export class UniswapV4Service {
         }
         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 UniswapV4Repository.getStoredPools();
+        const res = await Promise.all(UNIV4_CHAINIDS.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
+                const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
+                log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
+                let fromBlock;
+                if (storedPoolsPerChain.length > 0) {
+                    fromBlock = Math.max(...storedPoolsPerChain.map(x => x.fetchAtBlock)) + 1;
+                }
+                else {
+                    fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
+                }
+                const toBlock = await jsonRPCprovider.getBlockNumber();
+                const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
+                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock
+                // fromBlock + 10_000
+                );
+                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
+                    return {
+                        poolId: id,
+                        chainId: chainId,
+                        currency0: currency0,
+                        currency1: currency1,
+                        tickSpacing: tickSpacing,
+                        lpFee: fee,
+                        hooks: hooks,
+                        fetchedAtBlock: Number(log.blockNumber),
+                    };
+                }));
+                log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
+                /** Extra calls batch to get the collateral addresses */
+                const resCurrencies = await ChainInteractionService(chainId).fetchState(decodedPools.flatMap(pool => {
+                    return [
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: pool.currency0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: pool.currency0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: pool.currency1,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: pool.currency1,
+                        },
+                    ].filter(x => x.target !== NULL_ADDRESS);
+                }));
+                let index = 0;
+                for (const pool of decodedPools) {
+                    let symbolCurrency0 = "UNKNOWN";
+                    let decimalsCurrency0 = 18;
+                    if (pool.currency0 !== NULL_ADDRESS) {
+                        try {
+                            symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
+                            if (symbolCurrency0.includes("/") || symbolCurrency0.includes("\u0000")) {
+                                symbolCurrency0 = "INVALID";
+                            }
+                            decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
+                        }
+                        catch {
+                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency0 ${pool.currency0} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        }
+                    }
+                    else {
+                        symbolCurrency0 = "ETH";
+                        decimalsCurrency0 = 18;
+                        index -= 2;
+                    }
+                    let symbolCurrency1 = "UNKNOWN";
+                    let decimalsCurrency1 = 18;
+                    if (pool.currency1 !== NULL_ADDRESS) {
+                        try {
+                            symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
+                            if (symbolCurrency1.includes("/") || symbolCurrency1.includes("\u0000")) {
+                                symbolCurrency1 = "INVALID";
+                            }
+                            decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
+                        }
+                        catch {
+                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency1 ${pool.currency1} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        }
+                    }
+                    else {
+                        symbolCurrency1 = "ETH";
+                        decimalsCurrency1 = 18;
+                        index -= 2;
+                    }
+                    const id = pool.poolId;
+                    perChainIdRes[id ?? "unknownKey"] = {
+                        chainId: pool.chainId,
+                        currency0: pool.currency0,
+                        currency1: pool.currency1,
+                        decimalsCurrency0,
+                        decimalsCurrency1,
+                        hooks: pool.hooks,
+                        fetchedAtBlock: pool.fetchedAtBlock,
+                        lpFee: pool.lpFee,
+                        poolId: id,
+                        poolKey: pool.poolKey,
+                        symbolCurrency0,
+                        symbolCurrency1,
+                        tickSpacing: pool.tickSpacing,
+                    };
+                    index += 4;
+                }
+            }
+            catch (e) {
+                log.error(`issue when fetching UniswapV4 pools on ${NETWORK_LABELS[chainId]}`, e);
+            }
+            return perChainIdRes;
+        }));
+        UNIV4_CHAINIDS.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) {
+            if (tableData.filter(p => p.chainId === chainId).length > 0) {
+                try {
+                    await UniswapV4Repository.createMany(tableData
+                        .filter(point => point.chainId === chainId)
+                        .map(pool => ({
+                        fetchAtBlock: pool.fetchedAtBlock,
+                        caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
+                        chainId: pool.chainId,
+                        entityData: pool,
+                        id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
+                        type: LoggedEntityType.UNISWAP_V4,
+                    })));
+                    log.info(`✅ successfully saved vaults to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+                }
+                catch (e) {
+                    log.error("getUniswapV4Pools/LoggedTableUpdate", e);
+                    throw new Error(`Error while saving UniV4 pools to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+                }
+            }
+        }
+        log.info(`✅ successfully fetched ${tableData.length} new pool(s) on UniswapV4`);
+        // _ Merge previoulsy stored pools with newly fetched ones
+        // TODO optimize this part
+        if (storedPools.length > 0) {
+            for (const pool of storedPools) {
+                const chainId = pool.chainId;
+                if (!pools[chainId])
+                    pools[chainId] = {};
+                pools[chainId][pool.entityData.poolId] = pool.entityData;
+            }
+        }
+        log.info("👋 exiting getUniswapV4Pools");
+        return pools;
+    }
 }

package/dist/src/utils/prices/services/coinGeckoService.js

@@ -28,7 +28,7 @@ export default class CoingeckoService {
         for (let i = 0; i < tickers.length; i += chunkSize) {
             chunks.push(tickers.slice(i, Math.min(tickers.length, i + chunkSize)));
         }
-        const promises = await Promise.all(chunks.map(async (chunk) => {
+        const promises = (await Promise.all(chunks.map(async (chunk) => {
             const url = this.buildUrl(chunk);
             return axios
                 .get(url, { timeout: 10000 })
@@ -37,7 +37,7 @@ export default class CoingeckoService {
                 log.error("❌ CoingeckoService not responding", err);
                 throw "❌ CoingeckoService not responding";
             });
-        }));
+        }))).filter(result => !!result);
         return promises.reduce((acc, val) => acc.concat(val), []);
     }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation> Need to be typed according to coinguekko answer type
@@ -56,6 +56,6 @@ export default class CoingeckoService {
                 rate: data.data.coins[`coingecko:${args.ticker}`].price ?? -1,
             };
         })
-            .filter(item => item !== undefined);
+            .filter(item => !!item);
     }
 }

package/dist/src/utils/prices/services/defillamaService.js

@@ -38,16 +38,16 @@ export default class DefillamaService {
             .map(token => {
             const args = token.args;
             if (!args?.address || !args?.chain)
-                return;
+                return undefined;
             if (!data.data.coins[`${args?.chain}:${args.address}`]?.price) {
                 log.warn(`❌ DefillamaService data failed for ${token.symbol} with address ${args.address}`);
-                return;
+                return undefined;
             }
             return {
                 token: token.symbol,
                 rate: data.data.coins[`${args?.chain}:${args.address}`].price ?? -1,
             };
         })
-            .filter(item => item !== undefined);
+            .filter(item => !!item);
     }
 }

package/dist/src/utils/prices/services/erc4626Service.js

@@ -10,8 +10,10 @@ export default class ERC4626Service {
             .filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.ERC4626)
             .map(async (token) => {
             const args = token.args;
-            if (!args?.chainId || !args.address || !args.vaultToken)
-                return log.warn(`❌ ERC4626Service ticker not found for ${token.symbol}`);
+            if (!args?.chainId || !args.address || !args.vaultToken) {
+                log.warn(`❌ ERC4626Service ticker not found for ${token.symbol}`);
+                return undefined;
+            }
             const rate = await getERC4626Price(args.chainId, args.address, args.decimals, args.vaultDecimals);
             // 2 returned tokens as stUSD and STUSD (business requirement)
             const price = await this.priceCalculation(rate, args.vaultToken);
@@ -21,8 +23,8 @@ export default class ERC4626Service {
             ];
             return res;
         });
-        const resolvedPrices = await Promise.all(pricePromises);
-        return resolvedPrices.flat().filter(price => price !== undefined && price !== null);
+        const resolvedPrices = (await Promise.all(pricePromises)).filter(result => !!result);
+        return resolvedPrices.flat();
     }
     async priceCalculation(rate, vaultToken) {
         try {