@merkl/api 0.20.52 → 0.20.54

package/package.json

@@ -7,42 +7,42 @@
     "dist"
   ],
   "scripts": {
+    "build:ci": "bun tsc -b",
+    "build:local": "bun tsc -b",
     "cmd": "bun run scripts/cmd.ts",
     "container": "chmod +x scripts/run.sh && FORCE_COLOR=true ./scripts/run.sh bun run ./scripts/config.ts",
     "db:generate": "bunx prisma generate --schema database/api/schema.prisma && bunx prisma generate --schema database/engine/schema.prisma",
+    "db:migrate:create": "bunx prisma migrate dev --create-only --schema database/api/schema.prisma",
     "db:migrate:deploy": "bunx prisma migrate deploy --schema database/api/schema.prisma",
     "db:migrate:dev": "bunx prisma migrate dev --schema database/api/schema.prisma",
-    "db:migrate:create": "bunx prisma migrate dev --create-only --schema database/api/schema.prisma",
     "db:migrate:reset": "bunx prisma migrate reset --schema database/api/schema.prisma",
     "db:studio:api": "bunx prisma studio --schema database/api/schema.prisma",
     "db:studio:engine": "bunx prisma studio --schema database/engine/schema.prisma",
-    "build:ci": "bun tsc -b",
-    "build:local": "bun tsc -b",
     "lint": "bun biome check --diagnostic-level error --write ./src && bun biome check --diagnostic-level error --write ./tests",
     "lint:ci": "bun biome check --diagnostic-level error ./src",
     "lint:test": "bun biome check --write ./tests",
     "pack": "chmod +x scripts/pack.sh && ./scripts/pack.sh",
+    "postpublish": "bun run use:gitReadme",
+    "prepublishOnly": "bun run use:packageReadme",
     "pull-db": "prisma db pull && prisma generate",
     "pull-db:local": "DATABASE_URL=postgresql://postgres:postgres@0.0.0.0:5432/merkl-calc prisma db pull && prisma generate",
+    "set:dungeon-keeper": "bun run src/jobs/set-dungeon-keeper.ts",
     "setup": "code --install-extension .vscode/extensions/merkl:helpers-0.0.1.vsix",
     "sql": "lsof -i :1234 && lsof -i :2345",
+    "start:etl:pendings": "bun run src/jobs/pendings.ts",
+    "start:etl:reward-breakdowns": "bun run src/jobs/reward-breakdowns.ts",
+    "start:etl:rewards": "bun run src/jobs/rewards.ts",
     "start:local": "bun scripts/start.ts",
     "sync": "bun install && git submodule update --init --recursive && git submodule foreach 'bun install' && bun db:generate",
     "test": "bun test",
-    "start:etl:rewards": "bun run src/jobs/rewards.ts",
-    "start:etl:reward-breakdowns": "bun run src/jobs/reward-breakdowns.ts",
-    "start:etl:pendings": "bun run src/jobs/pendings.ts",
-    "update:prices": "bun run src/jobs/prices.ts",
     "update:dynamic-data": "bun run src/jobs/dynamic-data.ts",
-    "update:euler-vaults": "bun run src/jobs/update-euler-vaults",
     "update:dynamic-data:v4": "bun run src/jobs/update-dynamic-data.ts",
-    "update:uniswap-v4-pools": "bun run src/jobs/update-uniswap-v4-pools.ts",
+    "update:euler-vaults": "bun run src/jobs/update-euler-vaults",
+    "update:prices": "bun run src/jobs/prices.ts",
     "update:rpc-calls-cache": "bun run src/jobs/update-rpc-calls-cache.ts",
-    "set:dungeon-keeper": "bun run src/jobs/set-dungeon-keeper.ts",
-    "use:packageReadme": "mv 'README.md' 'git.README.md' && mv 'README.package.md' 'README.md'",
+    "update:uniswap-v4-pools": "bun run src/jobs/update-uniswap-v4-pools.ts",
     "use:gitReadme": "mv 'README.md' 'README.package.md' && mv 'git.README.md' 'README.md'",
-    "prepublishOnly": "bun run use:packageReadme",
-    "postpublish": "bun run use:gitReadme"
+    "use:packageReadme": "mv 'README.md' 'git.README.md' && mv 'README.package.md' 'README.md'"
   },
   "dependencies": {
     "@bogeychan/elysia-logger": "^0.1.8",
@@ -107,5 +107,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.20.52"
+  "version": "v0.20.54"
 }

package/dist/src/engine/dynamicData/utils/getUniswapV4Pools.d.ts

@@ -1,10 +0,0 @@
-import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
-export declare const UniV4ChainIdArray: MerklChainId[];
-type UniV4ChainId = (typeof UniV4ChainIdArray)[number];
-export type UniswapV4PoolsReturnType = {
-    [chainId in MerklChainId]?: {
-        [poolId: string]: UniswapV4PoolType;
-    };
-};
-export declare function getUniswapV4Pools(chainId?: UniV4ChainId): Promise<UniswapV4PoolsReturnType>;
-export {};

package/dist/src/engine/dynamicData/utils/getUniswapV4Pools.js

@@ -1,188 +0,0 @@
-import { log } from "@/utils/logger";
-import { providers } from "@/utils/providers";
-import { apiDbClient } from "@db";
-import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
-import { safeFetchLogs } from "./fetchLogs";
-import { LoggedEntityType } from "./getEulerV2Vaults";
-export const UniV4ChainIdArray = Object.keys(UniswapV4Addresses).map((x) => Number(x));
-export async function getUniswapV4Pools(chainId) {
-    let chainIdArray;
-    if (!!chainId) {
-        chainIdArray = [chainId];
-    }
-    else {
-        chainIdArray = UniV4ChainIdArray;
-    }
-    const pools = {};
-    // 0_ Fetch all euler vaults from database
-    const storedPools = await apiDbClient.logged.findMany({
-        where: { type: LoggedEntityType.UNISWAP_V4 },
-    });
-    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 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;
-            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;
-    }));
-    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 chainIdArray) {
-        if (tableData.filter(p => p.chainId === chainId).length > 0) {
-            try {
-                await apiDbClient.logged.createMany({
-                    data: 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;
-}