@merkl/api 0.9.15

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

@@ -0,0 +1,24 @@
+import type { apiDbClient } from "@db";
+import type { Prisma } from "@db/api";
+import type { MerklChainId, UniswapV4PoolType } from "@sdk";
+export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    poolKey: import("@sinclair/typebox").TObject<{
+        currency0: import("@sinclair/typebox").TString;
+        currency1: import("@sinclair/typebox").TString;
+        fee: import("@sinclair/typebox").TNumber;
+        tickSpacing: import("@sinclair/typebox").TNumber;
+        hooks: import("@sinclair/typebox").TString;
+    }>;
+    poolId: import("@sinclair/typebox").TString;
+    decimalsCurrency0: import("@sinclair/typebox").TNumber;
+    decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    symbolCurrency0: import("@sinclair/typebox").TString;
+    symbolCurrency1: import("@sinclair/typebox").TString;
+}>>;
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
+export type UniswapV4PoolsEntity = typeof UniswapV4PoolsDto.static;
+export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];

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

@@ -0,0 +1,17 @@
+import { t } from "elysia";
+const UniswapV4PoolKeyDto = t.Object({
+    currency0: t.String(),
+    currency1: t.String(),
+    fee: t.Numeric(),
+    tickSpacing: t.Numeric(),
+    hooks: t.String(),
+});
+const UniswapV4PoolDto = t.Object({
+    poolKey: UniswapV4PoolKeyDto,
+    poolId: t.String(),
+    decimalsCurrency0: t.Numeric(),
+    decimalsCurrency1: t.Numeric(),
+    symbolCurrency0: t.String(),
+    symbolCurrency1: t.String(),
+});
+export const UniswapV4PoolsDto = t.Record(t.String(), UniswapV4PoolDto);

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

@@ -0,0 +1,13 @@
+import type { LoggedCreateBody } from "./uniswapV4.model";
+export declare abstract class UniswapV4Repository {
+    static getStoredPools(): Promise<{
+        id: string;
+        type: import("@db/api").$Enums.LoggedEntityType;
+        address: string | null;
+        chainId: number;
+        fetchAtBlock: number;
+        caughtFromAddress: string;
+        entityData: import("database/api/.generated/runtime/library").JsonValue;
+    }[]>;
+    static createMany(data: LoggedCreateBody): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+}

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

@@ -0,0 +1,12 @@
+import { apiDbClient } from "@db";
+import { LoggedEntityType } from "@db/api";
+export class UniswapV4Repository {
+    static async getStoredPools() {
+        return await apiDbClient.logged.findMany({
+            where: { type: LoggedEntityType.UNISWAP_V4 },
+        });
+    }
+    static async createMany(data) {
+        return await apiDbClient.logged.createMany({ data });
+    }
+}

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

@@ -0,0 +1,22 @@
+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<{
+        [x: string]: {
+            poolId: string;
+            poolKey: {
+                hooks: string;
+                fee: number;
+                tickSpacing: number;
+                currency0: string;
+                currency1: string;
+            };
+            decimalsCurrency0: number;
+            decimalsCurrency1: number;
+            symbolCurrency0: string;
+            symbolCurrency1: string;
+        };
+    }>;
+    static getPools(): Promise<UniswapV4PoolsReturnType>;
+}

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

@@ -0,0 +1,247 @@
+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 { UniswapV4Repository } from "./uniswapV4.repository";
+export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
+export class UniswapV4Service {
+    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,
+            });
+        }
+        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 };
+        }
+        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;
+    }
+}